@selesai/code 0.13.40 → 0.14.3

package/dist/core/settings-manager.d.ts

@@ -1,6 +1,6 @@
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { type Model, type Transport } from "@earendil-works/pi-ai";
-import type { TuiMode as RendererTuiMode, ScrollViewScrollbar, TerminalCapabilities } from "@earendil-works/pi-tui";
+import type { TuiMode as RendererTuiMode, ScrollViewScrollbar, TerminalCapabilities, WheelScrollLines } from "@earendil-works/pi-tui";
 export interface CompactionModelOverride {
     reserveTokens?: number;
     keepRecentTokens?: number;
@@ -56,22 +56,28 @@ export declare const CACHE_WARMING_MODES: readonly ["off", "streaming", "idle"];
 export type CacheWarmingMode = (typeof CACHE_WARMING_MODES)[number];
 export interface MarkdownSettings {
     codeBlockIndent?: string;
+    mermaid?: MermaidRenderingMode;
 }
 export interface WarningSettings {
     anthropicExtraUsage?: boolean;
 }
-export interface AutoHandoffSettings {
-    enabled?: boolean;
-    thresholdTokens?: number;
-}
-export interface CapabilityGatewaySettings {
-    routing?: {
-        jev?: {
-            enabled?: boolean;
-        };
-    };
+/**
+ * How the codemode tool presents tools while it is active.
+ * - `on`: declared tools that scripts can call get a note on calling them from scripts appended to
+ *   their description; the codemode description lists only the tools without `direct` exposure.
+ * - `only`: the codemode description lists every tool scripts can call, and active `direct` tools are
+ *   not declared to the model.
+ */
+export type CodemodeMode = "on" | "only";
+export interface CodemodeSettings {
+    /** Default: `on`. */
+    mode?: CodemodeMode;
+    /** Estimated tokens (characters / 4) the codemode description may spend on tool declarations. Default: 3000. */
+    inlineBudget?: number;
 }
 export type DefaultProjectTrust = "ask" | "always" | "never";
+/** true hides all startup output, "header" keeps only the startup header. */
+export type QuietStartup = boolean | "header";
 export type TransportSetting = Transport;
 /**
  * Package source for npm/git packages.
@@ -92,7 +98,6 @@ export interface Settings {
     defaultProvider?: string;
     defaultModel?: string;
     defaultThinkingLevel?: ThinkingLevel;
-    /** Per-model default thinking overrides, keyed by "provider/modelId". */
     modelThinkingLevels?: Record<string, ThinkingLevel>;
     transport?: TransportSetting;
     steeringMode?: "all" | "one-at-a-time";
@@ -105,7 +110,7 @@ export interface Settings {
     showCacheMissNotices?: boolean;
     externalEditor?: string;
     shellPath?: string;
-    quietStartup?: boolean;
+    quietStartup?: QuietStartup;
     defaultProjectTrust?: DefaultProjectTrust;
     shellCommandPrefix?: string;
     npmCommand?: string[];
@@ -113,6 +118,7 @@ export interface Settings {
     enableInstallTelemetry?: boolean;
     enableAnalytics?: boolean;
     trackingId?: string;
+    deviceId?: string;
     packages?: PackageSource[];
     extensions?: string[];
     skills?: string[];
@@ -120,13 +126,9 @@ export interface Settings {
     themes?: string[];
     agents?: string[];
     terminal?: TerminalSettings;
-    tuiMode?: TuiMode;
-    defaultTools?: string[];
-    fullscreenExitOutput?: FullscreenExitOutput;
-    fullscreenScrollbar?: ScrollViewScrollbar;
-    fullscreenCopyOnSelect?: boolean;
     images?: ImageSettings;
     enabledModels?: string[];
+    defaultTools?: string[];
     doubleEscapeAction?: "fork" | "tree" | "none";
     treeFilterMode?: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
     thinkingBudgets?: ThinkingBudgetsSettings;
@@ -136,15 +138,34 @@ export interface Settings {
     showHardwareCursor?: boolean;
     markdown?: MarkdownSettings;
     warnings?: WarningSettings;
-    autoHandoff?: AutoHandoffSettings;
-    capabilityGateway?: CapabilityGatewaySettings;
+    codemode?: CodemodeSettings;
     sessionDir?: string;
     extensionHost?: Record<string, "selesai" | "pi">;
     httpProxy?: string;
     httpIdleTimeoutMs?: number;
     cacheWarming?: CacheWarmingMode;
     websocketConnectTimeoutMs?: number;
+    tuiMode?: TuiMode;
+    fullscreenExitOutput?: FullscreenExitOutput;
+    fullscreenScrollbar?: ScrollViewScrollbar;
+    fullscreenCopyOnSelect?: boolean;
+    fullscreenWheelScrollLines?: WheelScrollLines;
 }
+/** Tools enabled at startup when `defaultTools` does not change them. */
+export declare const DEFAULT_TOOL_NAMES: readonly string[];
+/** Whether a tool selection entry is a `+name` or `-name` modifier. */
+export declare function isToolModifier(entry: unknown): boolean;
+/**
+ * Validate a tool list from `--tools` or the SDK `tools` option. It is either an allowlist of plain
+ * names and patterns or a list of only `+name`/`-name` entries with exact names. Returns the
+ * problem, or undefined when the list is valid.
+ */
+export declare function getToolListError(entries: readonly string[]): string | undefined;
+/**
+ * Apply the `+name` and `-name` entries of `entries` to `base` in order: `+name` adds a tool and
+ * `-name` removes one. Other entries are ignored.
+ */
+export declare function applyToolModifiers(base: readonly string[], entries: readonly string[]): string[];
 export type SettingsScope = "global" | "project";
 export interface SettingsManagerCreateOptions {
     projectTrusted?: boolean;
@@ -154,6 +175,7 @@ export interface SettingsStorage {
 }
 export interface SettingsError {
     scope: SettingsScope;
+    path?: string;
     error: Error;
 }
 export declare class FileSettingsStorage implements SettingsStorage {
@@ -182,19 +204,22 @@ export declare class SettingsManager {
     private projectSettingsLoadError;
     private writeQueue;
     private errors;
+    private settingsPaths;
     private constructor();
     /** Create a SettingsManager that loads from files */
     static create(cwd: string, agentDir?: string, options?: SettingsManagerCreateOptions): SettingsManager;
     /** Create a SettingsManager from an arbitrary storage backend */
     static fromStorage(storage: SettingsStorage, options?: SettingsManagerCreateOptions): SettingsManager;
-    /** Seed new settings fields into the user's global settings file without overwriting configured values. */
-    private ensureAutoHandoffDefaults;
+    /** Create a manager while retaining optional file paths for reported storage errors. */
+    private static fromStorageWithPaths;
     /** Create an in-memory SettingsManager (no file I/O) */
     static inMemory(settings?: Partial<Settings>, options?: SettingsManagerCreateOptions): SettingsManager;
     private static loadFromStorage;
     private static tryLoadFromStorage;
     /** Migrate old settings format to new format */
     private static migrateSettings;
+    /** A copy of the effective settings: global and project settings merged, with overrides. */
+    getSettings(): Settings;
     getGlobalSettings(): Settings;
     getProjectSettings(): Settings;
     /** Merged effective settings (project overrides global, nested objects merge recursively). */
@@ -293,8 +318,8 @@ export declare class SettingsManager {
     setShowCacheMissNotices(show: boolean): void;
     getShellPath(): string | undefined;
     setShellPath(path: string | undefined): void;
-    getQuietStartup(): boolean;
-    setQuietStartup(quiet: boolean): void;
+    getQuietStartup(): QuietStartup;
+    setQuietStartup(quiet: QuietStartup): void;
     getDefaultProjectTrust(): DefaultProjectTrust;
     setDefaultProjectTrust(defaultProjectTrust: DefaultProjectTrust): void;
     getShellCommandPrefix(): string | undefined;
@@ -309,6 +334,12 @@ export declare class SettingsManager {
     getTrackingId(): string | undefined;
     /** Set the analytics opt-in preference; generates a tracking identifier on first opt-in */
     setEnableAnalytics(enabled: boolean): void;
+    /**
+     * Stable ID of this installation, e.g. sent to OpenAI as its agent host ID.
+     * Created on first use. Project settings are ignored so a committed project
+     * settings file cannot give every clone the same ID.
+     */
+    getOrCreateDeviceId(): string;
     getPackages(): PackageSource[];
     setPackages(packages: PackageSource[]): void;
     setProjectPackages(packages: PackageSource[]): void;
@@ -336,12 +367,14 @@ export declare class SettingsManager {
     setShowTerminalProgress(enabled: boolean): void;
     getTuiMode(): TuiMode;
     setTuiMode(mode: TuiMode): void;
-    getFullscreenScrollbar(): ScrollViewScrollbar;
-    setFullscreenScrollbar(mode: ScrollViewScrollbar): void;
     getFullscreenExitOutput(): FullscreenExitOutput;
     setFullscreenExitOutput(output: FullscreenExitOutput): void;
+    getFullscreenScrollbar(): ScrollViewScrollbar;
+    setFullscreenScrollbar(mode: ScrollViewScrollbar): void;
     getFullscreenCopyOnSelect(): boolean;
     setFullscreenCopyOnSelect(enabled: boolean): void;
+    getFullscreenWheelScrollLines(): WheelScrollLines;
+    setFullscreenWheelScrollLines(lines: WheelScrollLines): void;
     getImageAutoResize(): boolean;
     setImageAutoResize(enabled: boolean): void;
     getBlockImages(): boolean;
@@ -351,6 +384,7 @@ export declare class SettingsManager {
     setImageCaptionContextTokens(tokens: number): void;
     setBlockImages(blocked: boolean): void;
     getEnabledModels(): string[] | undefined;
+    /** The resolved `defaultTools` selection, or undefined when no settings layer sets it. */
     getDefaultTools(): string[] | undefined;
     setEnabledModels(patterns: string[] | undefined): void;
     getDoubleEscapeAction(): "fork" | "tree" | "none";
@@ -366,12 +400,8 @@ export declare class SettingsManager {
     getAutocompleteMaxVisible(): number;
     setAutocompleteMaxVisible(maxVisible: number): void;
     getCodeBlockIndent(): string;
+    getMermaidRenderingMode(): MermaidRenderingMode;
+    setMermaidRenderingMode(mode: MermaidRenderingMode): void;
     getWarnings(): WarningSettings;
     setWarnings(warnings: WarningSettings): void;
-    getAutoHandoffEnabled(): boolean;
-    getCapabilityGatewayJevEnabled(): boolean;
-    setCapabilityGatewayJevEnabled(enabled: boolean): void;
-    setAutoHandoffEnabled(enabled: boolean): void;
-    getAutoHandoffThresholdTokens(): number;
-    setAutoHandoffThresholdTokens(tokens: number): void;
 }

package/dist/core/settings-manager.js

@@ -5,6 +5,7 @@ import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
 const DEFAULT_COMPACTION_TOKEN_SETTINGS = {
     reserveTokens: 16384,
@@ -12,10 +13,6 @@ const DEFAULT_COMPACTION_TOKEN_SETTINGS = {
 };
 /** Cache-warming profile. "idle" also warms between agent runs. */
 export const CACHE_WARMING_MODES = ["off", "streaming", "idle"];
-const DEFAULT_AUTO_HANDOFF_SETTINGS = {
-    enabled: false,
-    thresholdTokens: 128_000,
-};
 function isMergeableObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -34,9 +31,71 @@ function deepMergeObjects(base, overrides) {
     }
     return result;
 }
+/** Tools enabled at startup when `defaultTools` does not change them. */
+export const DEFAULT_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
+/** Whether a tool selection entry is a `+name` or `-name` modifier. */
+export function isToolModifier(entry) {
+    return typeof entry === "string" && (entry.startsWith("+") || entry.startsWith("-"));
+}
+/**
+ * Validate a tool list from `--tools` or the SDK `tools` option. It is either an allowlist of plain
+ * names and patterns or a list of only `+name`/`-name` entries with exact names. Returns the
+ * problem, or undefined when the list is valid.
+ */
+export function getToolListError(entries) {
+    const modifiers = entries.filter(isToolModifier);
+    if (modifiers.length === 0)
+        return undefined;
+    if (modifiers.length < entries.length)
+        return "tool names cannot be mixed with +name or -name entries";
+    const pattern = modifiers.find((entry) => entry.includes("*"));
+    if (pattern)
+        return `+name and -name entries take exact tool names, not patterns: ${pattern}`;
+    return undefined;
+}
+/**
+ * Apply the `+name` and `-name` entries of `entries` to `base` in order: `+name` adds a tool and
+ * `-name` removes one. Other entries are ignored.
+ */
+export function applyToolModifiers(base, entries) {
+    const tools = [...base];
+    for (const entry of entries) {
+        if (!isToolModifier(entry))
+            continue;
+        const name = entry.slice(1);
+        const index = tools.indexOf(name);
+        if (entry.startsWith("+") && index === -1 && name)
+            tools.push(name);
+        else if (entry.startsWith("-") && index !== -1)
+            tools.splice(index, 1);
+    }
+    return tools;
+}
+/**
+ * Merge `defaultTools` of two settings layers. A list with plain tool names replaces the inherited
+ * one; a list of only `+name`/`-name` entries is appended, so it modifies the inherited selection.
+ */
+function mergeDefaultTools(base, overrides) {
+    if (overrides === undefined)
+        return base;
+    // Settings files are not validated; a malformed value replaces instead of throwing here.
+    if (!Array.isArray(base) || !Array.isArray(overrides) || !overrides.every(isToolModifier))
+        return overrides;
+    return [...base, ...overrides];
+}
+/**
+ * Resolve a merged `defaultTools` list: plain names replace `DEFAULT_TOOL_NAMES`, then `+name` adds
+ * and `-name` removes a tool, in list order.
+ */
+function resolveDefaultTools(entries) {
+    const plain = entries.filter((entry) => !isToolModifier(entry));
+    return applyToolModifiers(plain.length > 0 || entries.length === 0 ? plain : DEFAULT_TOOL_NAMES, entries);
+}
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
 function deepMergeSettings(base, overrides) {
-    return deepMergeObjects(base, overrides);
+    const merged = deepMergeObjects(base, overrides);
+    const defaultTools = mergeDefaultTools(base.defaultTools, overrides.defaultTools);
+    return defaultTools === undefined ? merged : { ...merged, defaultTools };
 }
 function parseTimeoutSetting(value, settingName) {
     const timeoutMs = parseHttpIdleTimeoutMs(value);
@@ -48,6 +107,13 @@ function parseTimeoutSetting(value, settingName) {
     }
     return undefined;
 }
+function toSettingsError(scope, error, path) {
+    return {
+        scope,
+        ...(path ? { path } : {}),
+        error: error instanceof Error ? error : new Error(String(error)),
+    };
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
@@ -141,7 +207,8 @@ export class SettingsManager {
     projectSettingsLoadError = null; // Track if project settings file had parse errors
     writeQueue = Promise.resolve();
     errors;
-    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true) {
+    settingsPaths;
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true, settingsPaths = {}) {
         this.storage = storage;
         this.globalSettings = initialGlobal;
         this.projectSettings = initialProject;
@@ -149,43 +216,38 @@ export class SettingsManager {
         this.globalSettingsLoadError = globalLoadError;
         this.projectSettingsLoadError = projectLoadError;
         this.errors = [...initialErrors];
+        this.settingsPaths = settingsPaths;
         this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Create a SettingsManager that loads from files */
     static create(cwd, agentDir = getAgentDir(), options = {}) {
-        const storage = new FileSettingsStorage(cwd, agentDir);
-        return SettingsManager.fromStorage(storage, options);
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        const storage = new FileSettingsStorage(resolvedCwd, resolvedAgentDir);
+        return SettingsManager.fromStorageWithPaths(storage, options, {
+            global: join(resolvedAgentDir, "settings.json"),
+            project: join(resolvedCwd, CONFIG_DIR_NAME, "settings.json"),
+        });
     }
     /** Create a SettingsManager from an arbitrary storage backend */
     static fromStorage(storage, options = {}) {
+        return SettingsManager.fromStorageWithPaths(storage, options);
+    }
+    /** Create a manager while retaining optional file paths for reported storage errors. */
+    static fromStorageWithPaths(storage, options, settingsPaths = {}) {
         const projectTrusted = options.projectTrusted ?? true;
         const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
         const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project", projectTrusted);
         const initialErrors = [];
         if (globalLoad.error) {
-            initialErrors.push({ scope: "global", error: globalLoad.error });
+            initialErrors.push(toSettingsError("global", globalLoad.error, settingsPaths.global));
         }
         if (projectLoad.error) {
-            initialErrors.push({ scope: "project", error: projectLoad.error });
+            initialErrors.push(toSettingsError("project", projectLoad.error, settingsPaths.project));
         }
-        const manager = new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted);
-        manager.ensureAutoHandoffDefaults();
+        const manager = new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted, settingsPaths);
         return manager;
     }
-    /** Seed new settings fields into the user's global settings file without overwriting configured values. */
-    ensureAutoHandoffDefaults() {
-        if (this.globalSettingsLoadError)
-            return;
-        const existing = this.globalSettings.autoHandoff;
-        const enabled = existing?.enabled ?? DEFAULT_AUTO_HANDOFF_SETTINGS.enabled;
-        const thresholdTokens = existing?.thresholdTokens ?? DEFAULT_AUTO_HANDOFF_SETTINGS.thresholdTokens;
-        if (existing?.enabled === enabled && existing?.thresholdTokens === thresholdTokens)
-            return;
-        this.globalSettings.autoHandoff = { enabled, thresholdTokens };
-        this.markModified("autoHandoff", "enabled");
-        this.markModified("autoHandoff", "thresholdTokens");
-        this.save();
-    }
     /** Create an in-memory SettingsManager (no file I/O) */
     static inMemory(settings = {}, options = {}) {
         const storage = new InMemorySettingsStorage();
@@ -205,7 +267,7 @@ export class SettingsManager {
         if (!content) {
             return {};
         }
-        const settings = JSON.parse(content);
+        const settings = JSON.parse(stripBom(content));
         return SettingsManager.migrateSettings(settings);
     }
     static tryLoadFromStorage(storage, scope, projectTrusted = true) {
@@ -261,6 +323,10 @@ export class SettingsManager {
         }
         return settings;
     }
+    /** A copy of the effective settings: global and project settings merged, with overrides. */
+    getSettings() {
+        return structuredClone(this.settings);
+    }
     getGlobalSettings() {
         return structuredClone(this.globalSettings);
     }
@@ -395,8 +461,7 @@ export class SettingsManager {
         }
     }
     recordError(scope, error) {
-        const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.errors.push({ scope, error: normalizedError });
+        this.errors.push(toSettingsError(scope, error, this.settingsPaths[scope]));
     }
     clearModifiedScope(scope) {
         if (scope === "global") {
@@ -430,7 +495,7 @@ export class SettingsManager {
     persistScopedSettings(scope, snapshotSettings, modifiedFields, modifiedNestedFields) {
         this.storage.withLock(scope, (current) => {
             const currentFileSettings = current
-                ? SettingsManager.migrateSettings(JSON.parse(current))
+                ? SettingsManager.migrateSettings(JSON.parse(stripBom(current)))
                 : {};
             const mergedSettings = { ...currentFileSettings };
             for (const field of modifiedFields) {
@@ -574,7 +639,9 @@ export class SettingsManager {
         return { ...(this.settings.modelThinkingLevels ?? {}) };
     }
     setModelThinkingLevel(provider, modelId, level) {
-        this.globalSettings.modelThinkingLevels ??= {};
+        if (!this.globalSettings.modelThinkingLevels) {
+            this.globalSettings.modelThinkingLevels = {};
+        }
         this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`] = level;
         this.markModified("modelThinkingLevels");
         this.save();
@@ -735,7 +802,8 @@ export class SettingsManager {
         this.save();
     }
     getQuietStartup() {
-        return this.settings.quietStartup ?? false;
+        const value = this.settings.quietStartup;
+        return value === true || value === "header" ? value : false;
     }
     setQuietStartup(quiet) {
         this.globalSettings.quietStartup = quiet;
@@ -799,6 +867,19 @@ export class SettingsManager {
         }
         this.save();
     }
+    /**
+     * Stable ID of this installation, e.g. sent to OpenAI as its agent host ID.
+     * Created on first use. Project settings are ignored so a committed project
+     * settings file cannot give every clone the same ID.
+     */
+    getOrCreateDeviceId() {
+        if (!this.globalSettings.deviceId) {
+            this.globalSettings.deviceId = randomUUID();
+            this.markModified("deviceId");
+            this.save();
+        }
+        return this.globalSettings.deviceId;
+    }
     getPackages() {
         return [...(this.settings.packages ?? [])];
     }
@@ -937,6 +1018,14 @@ export class SettingsManager {
         this.markModified("tuiMode");
         this.save();
     }
+    getFullscreenExitOutput() {
+        return this.settings.fullscreenExitOutput === "resume-hint" ? "resume-hint" : "transcript";
+    }
+    setFullscreenExitOutput(output) {
+        this.globalSettings.fullscreenExitOutput = output;
+        this.markModified("fullscreenExitOutput");
+        this.save();
+    }
     getFullscreenScrollbar() {
         const mode = this.settings.fullscreenScrollbar;
         return mode === "always" || mode === "hidden" ? mode : "auto";
@@ -946,14 +1035,6 @@ export class SettingsManager {
         this.markModified("fullscreenScrollbar");
         this.save();
     }
-    getFullscreenExitOutput() {
-        return this.settings.fullscreenExitOutput === "resume-hint" ? "resume-hint" : "transcript";
-    }
-    setFullscreenExitOutput(output) {
-        this.globalSettings.fullscreenExitOutput = output;
-        this.markModified("fullscreenExitOutput");
-        this.save();
-    }
     getFullscreenCopyOnSelect() {
         return this.settings.fullscreenCopyOnSelect ?? true;
     }
@@ -962,6 +1043,18 @@ export class SettingsManager {
         this.markModified("fullscreenCopyOnSelect");
         this.save();
     }
+    getFullscreenWheelScrollLines() {
+        const lines = this.settings.fullscreenWheelScrollLines;
+        return typeof lines === "number" && Number.isFinite(lines)
+            ? Math.max(1, Math.min(100, Math.floor(lines)))
+            : "auto";
+    }
+    setFullscreenWheelScrollLines(lines) {
+        this.globalSettings.fullscreenWheelScrollLines =
+            lines === "auto" ? lines : Math.max(1, Math.min(100, Math.floor(lines)));
+        this.markModified("fullscreenWheelScrollLines");
+        this.save();
+    }
     getImageAutoResize() {
         return this.settings.images?.autoResize ?? true;
     }
@@ -1014,9 +1107,12 @@ export class SettingsManager {
     getEnabledModels() {
         return this.settings.enabledModels;
     }
+    /** The resolved `defaultTools` selection, or undefined when no settings layer sets it. */
     getDefaultTools() {
         const tools = this.settings.defaultTools;
-        return tools ? [...tools] : undefined;
+        if (tools === undefined)
+            return undefined;
+        return resolveDefaultTools(Array.isArray(tools) ? tools.filter((tool) => typeof tool === "string") : []);
     }
     setEnabledModels(patterns) {
         this.globalSettings.enabledModels = patterns;
@@ -1076,6 +1172,16 @@ export class SettingsManager {
     getCodeBlockIndent() {
         return this.settings.markdown?.codeBlockIndent ?? "  ";
     }
+    getMermaidRenderingMode() {
+        const mode = this.settings.markdown?.mermaid;
+        return mode === "off" || mode === "final" ? mode : "streaming";
+    }
+    setMermaidRenderingMode(mode) {
+        this.globalSettings.markdown ??= {};
+        this.globalSettings.markdown.mermaid = mode;
+        this.markModified("markdown", "mermaid");
+        this.save();
+    }
     getWarnings() {
         return { ...(this.settings.warnings ?? {}) };
     }
@@ -1084,32 +1190,4 @@ export class SettingsManager {
         this.markModified("warnings");
         this.save();
     }
-    getAutoHandoffEnabled() {
-        return this.settings.autoHandoff?.enabled ?? DEFAULT_AUTO_HANDOFF_SETTINGS.enabled;
-    }
-    getCapabilityGatewayJevEnabled() {
-        return this.settings.capabilityGateway?.routing?.jev?.enabled ?? true;
-    }
-    setCapabilityGatewayJevEnabled(enabled) {
-        this.setGlobalSettings({ capabilityGateway: { routing: { jev: { enabled } } } });
-    }
-    setAutoHandoffEnabled(enabled) {
-        if (!this.globalSettings.autoHandoff) {
-            this.globalSettings.autoHandoff = {};
-        }
-        this.globalSettings.autoHandoff.enabled = enabled;
-        this.markModified("autoHandoff", "enabled");
-        this.save();
-    }
-    getAutoHandoffThresholdTokens() {
-        return this.settings.autoHandoff?.thresholdTokens ?? DEFAULT_AUTO_HANDOFF_SETTINGS.thresholdTokens;
-    }
-    setAutoHandoffThresholdTokens(tokens) {
-        if (!this.globalSettings.autoHandoff) {
-            this.globalSettings.autoHandoff = {};
-        }
-        this.globalSettings.autoHandoff.thresholdTokens = Math.max(1000, Math.floor(tokens));
-        this.markModified("autoHandoff", "thresholdTokens");
-        this.save();
-    }
 }

package/dist/core/skills.d.ts

@@ -28,7 +28,7 @@ export declare function validateName(name: string): string[];
 /**
  * Validate description per Agent Skills spec.
  */
-export declare function validateDescription(description: string | undefined): string[];
+export declare function validateDescription(description: unknown): string[];
 export interface LoadSkillsFromDirOptions {
     /** Directory to scan for skills */
     dir: string;
@@ -51,8 +51,11 @@ export declare function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Lo
  *
  * Skills with disableModelInvocation=true are excluded from the prompt
  * (they can only be invoked explicitly via /skill:name commands).
+ *
+ * `fileReadTool` names the tool that loads skill files; `indirect` names none, for a reader that
+ * is reachable only through another tool.
  */
-export declare function formatSkillsForPrompt(skills: Skill[], fileReadTool?: "read" | "bash"): string;
+export declare function formatSkillsForPrompt(skills: Skill[], fileReadTool?: "read" | "bash" | "indirect"): string;
 export interface LoadSkillsOptions {
     /** Working directory for project-local skills. */
     cwd: string;