shortcutxl 0.3.76 → 0.3.78

package/dist/app/resources/package-manager.js

@@ -8,14 +8,14 @@
  * resolved resource to support diagnostics and conflict detection.
  */
 import ignore from 'ignore';
-import { minimatch } from 'minimatch';
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
-import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { dirname, join, relative, resolve, sep } from 'node:path';
 import { CONFIG_DIR_NAME, getBundledSkillsDir } from '../../config.js';
 import { parseGitUrl } from '../../shared/scm/git.js';
+import { applyPatterns, isEnabledByOverrides } from './resource-patterns.js';
 /** Timeout for npm/git network operations. */
 const NETWORK_TIMEOUT_MS = 10000;
 function isOfflineModeEnabled() {
@@ -365,127 +365,6 @@ function collectResourceFiles(dir, resourceType) {
     }
     return collectFiles(dir, FILE_PATTERNS[resourceType]);
 }
-function matchesAnyPattern(filePath, patterns, baseDir) {
-    const rel = relative(baseDir, filePath);
-    const name = basename(filePath);
-    const isSkillFile = name === 'SKILL.md';
-    const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
-    const parentName = isSkillFile ? basename(parentDir) : undefined;
-    return patterns.some((pattern) => {
-        if (minimatch(rel, pattern) || minimatch(name, pattern) || minimatch(filePath, pattern)) {
-            return true;
-        }
-        if (!isSkillFile)
-            return false;
-        return (minimatch(parentRel, pattern) ||
-            minimatch(parentName, pattern) ||
-            minimatch(parentDir, pattern));
-    });
-}
-function normalizeExactPattern(pattern) {
-    if (pattern.startsWith('./') || pattern.startsWith('.\\')) {
-        return pattern.slice(2);
-    }
-    return pattern;
-}
-function matchesAnyExactPattern(filePath, patterns, baseDir) {
-    if (patterns.length === 0)
-        return false;
-    const rel = relative(baseDir, filePath);
-    const name = basename(filePath);
-    const isSkillFile = name === 'SKILL.md';
-    const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
-    return patterns.some((pattern) => {
-        const normalized = normalizeExactPattern(pattern);
-        if (normalized === rel || normalized === filePath) {
-            return true;
-        }
-        if (!isSkillFile)
-            return false;
-        return normalized === parentRel || normalized === parentDir;
-    });
-}
-function getOverridePatterns(entries) {
-    return entries.filter((pattern) => pattern.startsWith('!') || pattern.startsWith('+') || pattern.startsWith('-'));
-}
-function isEnabledByOverrides(filePath, patterns, baseDir) {
-    const overrides = getOverridePatterns(patterns);
-    const excludes = overrides
-        .filter((pattern) => pattern.startsWith('!'))
-        .map((pattern) => pattern.slice(1));
-    const forceIncludes = overrides
-        .filter((pattern) => pattern.startsWith('+'))
-        .map((pattern) => pattern.slice(1));
-    const forceExcludes = overrides
-        .filter((pattern) => pattern.startsWith('-'))
-        .map((pattern) => pattern.slice(1));
-    let enabled = true;
-    if (excludes.length > 0 && matchesAnyPattern(filePath, excludes, baseDir)) {
-        enabled = false;
-    }
-    if (forceIncludes.length > 0 && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
-        enabled = true;
-    }
-    if (forceExcludes.length > 0 && matchesAnyExactPattern(filePath, forceExcludes, baseDir)) {
-        enabled = false;
-    }
-    return enabled;
-}
-/**
- * Apply patterns to paths and return a Set of enabled paths.
- * Pattern types:
- * - Plain patterns: include matching paths
- * - `!pattern`: exclude matching paths
- * - `+path`: force-include exact path (overrides exclusions)
- * - `-path`: force-exclude exact path (overrides force-includes)
- */
-function applyPatterns(allPaths, patterns, baseDir) {
-    const includes = [];
-    const excludes = [];
-    const forceIncludes = [];
-    const forceExcludes = [];
-    for (const p of patterns) {
-        if (p.startsWith('+')) {
-            forceIncludes.push(p.slice(1));
-        }
-        else if (p.startsWith('-')) {
-            forceExcludes.push(p.slice(1));
-        }
-        else if (p.startsWith('!')) {
-            excludes.push(p.slice(1));
-        }
-        else {
-            includes.push(p);
-        }
-    }
-    // Step 1: Apply includes (or all if no includes)
-    let result;
-    if (includes.length === 0) {
-        result = [...allPaths];
-    }
-    else {
-        result = allPaths.filter((filePath) => matchesAnyPattern(filePath, includes, baseDir));
-    }
-    // Step 2: Apply excludes
-    if (excludes.length > 0) {
-        result = result.filter((filePath) => !matchesAnyPattern(filePath, excludes, baseDir));
-    }
-    // Step 3: Force-include (add back from allPaths, overriding exclusions)
-    if (forceIncludes.length > 0) {
-        for (const filePath of allPaths) {
-            if (!result.includes(filePath) && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
-                result.push(filePath);
-            }
-        }
-    }
-    // Step 4: Force-exclude (remove even if included or force-included)
-    if (forceExcludes.length > 0) {
-        result = result.filter((filePath) => !matchesAnyExactPattern(filePath, forceExcludes, baseDir));
-    }
-    return new Set(result);
-}
 /**
  * Default PackageManager implementation.
  *

package/dist/app/resources/resource-patterns.d.ts

@@ -0,0 +1,9 @@
+export declare function isEnabledByOverrides(filePath: string, patterns: string[], baseDir: string): boolean;
+/**
+ * Apply resource include/exclude patterns to paths.
+ *
+ * Plain patterns include glob matches, `!pattern` excludes glob matches,
+ * `+path` force-includes an exact path, and `-path` force-excludes one.
+ */
+export declare function applyPatterns(allPaths: string[], patterns: string[], baseDir: string): Set<string>;
+//# sourceMappingURL=resource-patterns.d.ts.map

package/dist/app/resources/resource-patterns.js

@@ -0,0 +1,120 @@
+import { Minimatch } from 'minimatch';
+import { basename, dirname, relative, sep } from 'node:path';
+const RESOURCE_PATTERN_OPTIONS = {
+    // Resource filters have always been case-sensitive on every platform. Keep
+    // that contract explicit rather than inheriting platform-specific behavior.
+    nocase: false,
+    // Preserve the minimatch semantics used before these helpers were extracted.
+    nocomment: false,
+    nonegate: false
+};
+function compilePatterns(patterns) {
+    return patterns.map((pattern) => new Minimatch(normalizePathSeparators(pattern), RESOURCE_PATTERN_OPTIONS));
+}
+function normalizePathSeparators(path) {
+    return path.split(sep).join('/');
+}
+function matchCandidates(filePath, baseDir) {
+    const relativePath = relative(baseDir, filePath);
+    const candidates = [relativePath, basename(filePath), filePath];
+    if (basename(filePath) === 'SKILL.md') {
+        const parentDir = dirname(filePath);
+        candidates.push(relative(baseDir, parentDir), basename(parentDir), parentDir);
+    }
+    return candidates.map(normalizePathSeparators);
+}
+function matchesAnyPattern(filePath, patterns, baseDir) {
+    const candidates = matchCandidates(filePath, baseDir);
+    return patterns.some((pattern) => candidates.some((candidate) => pattern.match(candidate)));
+}
+function normalizeExactPattern(pattern) {
+    pattern = normalizePathSeparators(pattern);
+    if (pattern.startsWith('./') || pattern.startsWith('.\\')) {
+        return pattern.slice(2);
+    }
+    return pattern;
+}
+function matchesAnyExactPattern(filePath, patterns, baseDir) {
+    if (patterns.length === 0)
+        return false;
+    const relativePath = normalizePathSeparators(relative(baseDir, filePath));
+    const candidates = [relativePath, normalizePathSeparators(filePath)];
+    if (basename(filePath) === 'SKILL.md') {
+        const parentDir = dirname(filePath);
+        candidates.push(normalizePathSeparators(relative(baseDir, parentDir)), normalizePathSeparators(parentDir));
+    }
+    return patterns.some((pattern) => candidates.includes(normalizeExactPattern(pattern)));
+}
+function getOverridePatterns(entries) {
+    return entries.filter((pattern) => pattern.startsWith('!') || pattern.startsWith('+') || pattern.startsWith('-'));
+}
+export function isEnabledByOverrides(filePath, patterns, baseDir) {
+    const overrides = getOverridePatterns(patterns);
+    const excludes = overrides
+        .filter((pattern) => pattern.startsWith('!'))
+        .map((pattern) => pattern.slice(1));
+    const forceIncludes = overrides
+        .filter((pattern) => pattern.startsWith('+'))
+        .map((pattern) => pattern.slice(1));
+    const forceExcludes = overrides
+        .filter((pattern) => pattern.startsWith('-'))
+        .map((pattern) => pattern.slice(1));
+    const excludeMatchers = compilePatterns(excludes);
+    let enabled = true;
+    if (excludeMatchers.length > 0 && matchesAnyPattern(filePath, excludeMatchers, baseDir)) {
+        enabled = false;
+    }
+    if (forceIncludes.length > 0 && matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
+        enabled = true;
+    }
+    if (forceExcludes.length > 0 && matchesAnyExactPattern(filePath, forceExcludes, baseDir)) {
+        enabled = false;
+    }
+    return enabled;
+}
+/**
+ * Apply resource include/exclude patterns to paths.
+ *
+ * Plain patterns include glob matches, `!pattern` excludes glob matches,
+ * `+path` force-includes an exact path, and `-path` force-excludes one.
+ */
+export function applyPatterns(allPaths, patterns, baseDir) {
+    const includes = [];
+    const excludes = [];
+    const forceIncludes = [];
+    const forceExcludes = [];
+    for (const pattern of patterns) {
+        if (pattern.startsWith('+')) {
+            forceIncludes.push(pattern.slice(1));
+        }
+        else if (pattern.startsWith('-')) {
+            forceExcludes.push(pattern.slice(1));
+        }
+        else if (pattern.startsWith('!')) {
+            excludes.push(pattern.slice(1));
+        }
+        else {
+            includes.push(pattern);
+        }
+    }
+    const includeMatchers = compilePatterns(includes);
+    const excludeMatchers = compilePatterns(excludes);
+    let result = includeMatchers.length === 0
+        ? [...allPaths]
+        : allPaths.filter((filePath) => matchesAnyPattern(filePath, includeMatchers, baseDir));
+    if (excludeMatchers.length > 0) {
+        result = result.filter((filePath) => !matchesAnyPattern(filePath, excludeMatchers, baseDir));
+    }
+    for (const filePath of allPaths) {
+        if (forceIncludes.length > 0 &&
+            !result.includes(filePath) &&
+            matchesAnyExactPattern(filePath, forceIncludes, baseDir)) {
+            result.push(filePath);
+        }
+    }
+    if (forceExcludes.length > 0) {
+        result = result.filter((filePath) => !matchesAnyExactPattern(filePath, forceExcludes, baseDir));
+    }
+    return new Set(result);
+}
+//# sourceMappingURL=resource-patterns.js.map

package/dist/app/session/forked-agent.d.ts

@@ -14,8 +14,8 @@
  *
  * Global concurrency is still capped to avoid overwhelming the LLM proxy.
  */
-import type { AssistantMessage, Message, Model, ThinkingLevel, ToolCall } from '../../ai/types.js';
-import type { ToolDefinition, ToolExecutionContext } from '../../core/core-types.js';
+import type { AssistantMessage, Message, Model, ToolCall } from '../../ai/types.js';
+import type { ThinkingLevel, ToolDefinition, ToolExecutionContext } from '../../core/core-types.js';
 import type { ShortcutAuthRecovery } from '../providers/shortcut-auth-recovery.js';
 export type { ThinkingLevel };
 export interface ForkedAgentParentContext {

package/dist/app/session/model-manager.js

@@ -6,7 +6,8 @@
  * Stable deps (agent, registries, managers) are constructor-injected.
  * Part of the AgentSession extracted modules.
  */
-import { clampThinkingLevel, computeNextModel, cycleThinkingLevel as computeNextThinkingLevel, filterInteractiveSelectableModels, getAvailableThinkingLevels } from './session-models.js';
+import { resolveModelReasoningLevel } from '../../ai/models.js';
+import { computeNextModel, cycleThinkingLevel as computeNextThinkingLevel, filterInteractiveSelectableModels } from './session-models.js';
 // ============================================================================
 // Manager
 // ============================================================================
@@ -47,7 +48,7 @@ export class ModelManager {
     }
     /** Set thinking level, clamped to model capabilities. Persists only on change. */
     setThinkingLevel(level) {
-        const effective = clampThinkingLevel(level, getAvailableThinkingLevels(this._agent.state.model));
+        const effective = resolveModelReasoningLevel(this._agent.state.model, level);
         const isChanging = effective !== this._agent.state.thinkingLevel;
         this._agent.setThinkingLevel(effective);
         if (isChanging) {

package/dist/app/session/session-lifecycle.js

@@ -5,8 +5,8 @@
  * existing sessions. Each function takes an explicit params object containing
  * the dependencies it needs, rather than reaching into class state.
  */
+import { resolveModelReasoningLevel } from '../../ai/models.js';
 import { configureAgentTempDir } from '../../config.js';
-import { DEFAULT_THINKING_LEVEL } from '../../core/index.js';
 /**
  * Create a new session, optionally with initial messages and parent tracking.
  * Returns true if completed, false if cancelled by extension.
@@ -119,7 +119,8 @@ export async function executeSwitchSession(params) {
     const hasThinkingEntry = sessionManager
         .getBranch()
         .some((entry) => entry.type === 'thinking_level_change');
-    const defaultThinkingLevel = settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL;
+    const defaultThinkingLevel = settingsManager.getDefaultThinkingLevel() ??
+        resolveModelReasoningLevel(agent.state.model, undefined);
     if (hasThinkingEntry) {
         // Restore thinking level if saved (setThinkingLevel clamps to model capabilities)
         setThinkingLevel(sessionContext.thinkingLevel);

package/dist/app/session/session-models.d.ts

@@ -16,6 +16,8 @@ export interface ModelCycleResult {
 export declare const THINKING_LEVELS: ThinkingLevel[];
 /** Thinking levels including xhigh (for supported models) */
 export declare const THINKING_LEVELS_WITH_XHIGH: ThinkingLevel[];
+/** Complete ordering used only when clamping a stale selection after a model switch. */
+export declare const ALL_THINKING_LEVELS: ThinkingLevel[];
 /** Check if a model supports thinking/reasoning. */
 export declare function supportsThinking(model: Model<any> | undefined): boolean;
 /** Check if a model supports xhigh thinking. */

package/dist/app/session/session-models.js

@@ -5,7 +5,7 @@
  * AgentSession delegates to these for cycling math and level clamping,
  * then handles persistence and extension events itself.
  */
-import { modelsAreEqual, supportsXhigh } from '../../ai/models.js';
+import { getModelReasoningLevels, modelsAreEqual } from '../../ai/models.js';
 import { SHORTCUT_MODEL_ID, SHORTCUT_OPENAI_MODEL_ID } from '../../model-ids.js';
 // ============================================================================
 // Constants
@@ -21,6 +21,16 @@ export const THINKING_LEVELS_WITH_XHIGH = [
     'high',
     'xhigh'
 ];
+/** Complete ordering used only when clamping a stale selection after a model switch. */
+export const ALL_THINKING_LEVELS = [
+    'off',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max'
+];
 /** Models shown in interactive model controls for known providers. Unlisted providers show all. */
 const INTERACTIVE_MODELS_PER_PROVIDER = {
     shortcut: new Set([
@@ -42,13 +52,11 @@ export function supportsThinking(model) {
 }
 /** Check if a model supports xhigh thinking. */
 export function supportsXhighThinking(model) {
-    return model ? supportsXhigh(model) : false;
+    return model ? getModelReasoningLevels(model).includes('xhigh') : false;
 }
 /** Get available thinking levels for a given model. */
 export function getAvailableThinkingLevels(model) {
-    if (!supportsThinking(model))
-        return ['off'];
-    return supportsXhighThinking(model) ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+    return model ? getModelReasoningLevels(model) : ['off'];
 }
 /**
  * Clamp a thinking level to the nearest available level.
@@ -57,7 +65,7 @@ export function getAvailableThinkingLevels(model) {
 export function clampThinkingLevel(level, availableLevels) {
     if (availableLevels.includes(level))
         return level;
-    const ordered = THINKING_LEVELS_WITH_XHIGH;
+    const ordered = ALL_THINKING_LEVELS;
     const available = new Set(availableLevels);
     const requestedIndex = ordered.indexOf(level);
     if (requestedIndex === -1) {

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

@@ -93,7 +93,7 @@ export interface Settings {
     lastChangelogVersion?: string;
     defaultProvider?: string;
     defaultModel?: string;
-    defaultThinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    defaultThinkingLevel?: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     transport?: TransportSetting;
     steeringMode?: 'all' | 'one-at-a-time';
     followUpMode?: 'all' | 'one-at-a-time';
@@ -220,8 +220,8 @@ export declare class SettingsManager {
     getFollowUpMode(): 'all' | 'one-at-a-time';
     getTheme(): string | undefined;
     setTheme(theme: string): void;
-    getDefaultThinkingLevel(): 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | undefined;
-    setDefaultThinkingLevel(level: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'): void;
+    getDefaultThinkingLevel(): 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined;
+    setDefaultThinkingLevel(level: 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'): void;
     getTransport(): TransportSetting;
     getRetryEnabled(): boolean;
     setRetryEnabled(enabled: boolean): void;

package/dist/app/shared/tools/execute-code/mog.d.ts

@@ -7,6 +7,8 @@
  */
 import { type CellEdit, type SheetEnginePool } from '@shortcut/mog-sandbox-runtime';
 import type { ToolDefinition } from '../../../../core/core-types.js';
+import { type ApprovalGate } from '../../../approvals/types.js';
+import type { ExcelApprovalPayload } from '../../../local/tools/execute-code/approval-payload.js';
 interface SheetExecResult {
     ok: boolean;
     output?: string;
@@ -20,6 +22,6 @@ declare const schema: import("@sinclair/typebox").TObject<{
     description: import("@sinclair/typebox").TString;
     code: import("@sinclair/typebox").TString;
 }>;
-export declare function createSheetExecTool(pool: SheetEnginePool): ToolDefinition<typeof schema, SheetExecResult>;
+export declare function createSheetExecTool(pool: SheetEnginePool, approval?: ApprovalGate<ExcelApprovalPayload>): ToolDefinition<typeof schema, SheetExecResult>;
 export {};
 //# sourceMappingURL=mog.d.ts.map

package/dist/app/shared/tools/execute-code/mog.js

@@ -11,6 +11,8 @@ import * as vm from 'node:vm';
 import * as ts from 'typescript';
 import { EXECUTE_CODE } from '../../../../tool-names.js';
 import { truncateOutput } from '../../../../utils/truncate.js';
+import { withPreApproval } from '../../../approvals/tool-approval.js';
+import { APPROVAL } from '../../../approvals/types.js';
 function transpileTS(code) {
     const result = ts.transpileModule(code, {
         compilerOptions: {
@@ -71,7 +73,7 @@ const schema = Type.Object({
         description: 'TypeScript code to execute. Use the available globals documented in the tool description. Use console.log() to return values. All API methods are async — use await.'
     })
 });
-export function createSheetExecTool(pool) {
+export function createSheetExecTool(pool, approval) {
     const assertSpreadsheetPolicy = (ctx) => {
         const spreadsheetPolicy = ctx?.permissionPolicy?.spreadsheet;
         if (!spreadsheetPolicy || spreadsheetPolicy.mutationBehavior !== 'deny') {
@@ -79,7 +81,7 @@ export function createSheetExecTool(pool) {
         }
         throw new Error('Spreadsheet execution is denied by the current permission policy.');
     };
-    return {
+    const tool = {
         name: EXECUTE_CODE,
         label: 'Sheet exec',
         description: TOOL_DESCRIPTION,
@@ -171,5 +173,19 @@ export function createSheetExecTool(pool) {
             };
         }
     };
+    if (!approval)
+        return tool;
+    return withPreApproval(tool, approval, (params) => ({
+        kind: EXECUTE_CODE,
+        title: 'Review spreadsheet operation',
+        choices: [APPROVAL.ACCEPT, APPROVAL.ACCEPT_ALL, APPROVAL.REJECT],
+        payload: {
+            kind: 'diff',
+            description: String(params.description ?? '').trim() || 'Updating the workbook'
+        }
+    }), {
+        isContentSafe: (_params, ctx) => ctx?.permissionPolicy?.spreadsheet.mutationBehavior === 'allow',
+        isHeadlessApprovalAllowed: (ctx) => ctx?.permissionPolicy?.spreadsheet.allowHeadlessApproval === true
+    });
 }
 //# sourceMappingURL=mog.js.map

package/dist/app/tools/bash.js

@@ -19,7 +19,7 @@ const TOOL_DESCRIPTION_BASE = `
 Execute a bash command in the current working directory. Returns stdout and stderr. 
 Output is truncated to ${DEFAULT_MAX_CHARS} characters. If truncated, full output is saved to a temp file. 
 For external APIs, prefer Python packages over raw curl (e.g. yfinance for market data). pip install if missing.
-Default timeout is 30 seconds. Override with the timeout parameter for long-running commands.
+Default timeout is 60 seconds. Override with the timeout parameter for long-running commands.
 `;
 const WINDOWS_SECTION = `
 Python and pip are available for data processing, scripting, and package installation.
@@ -75,7 +75,7 @@ const bashSchema = Type.Object({
     }),
     command: Type.String({ description: 'Bash command to execute' }),
     timeout: Type.Optional(Type.Number({
-        description: 'Timeout in seconds (default: 30). Increase for long-running commands.'
+        description: 'Timeout in seconds (default: 60). Increase for long-running commands.'
     })),
     connections: Type.Optional(Type.Array(Type.String(), {
         description: 'Names of configured connections whose credentials should be injected as environment variables for this command. ' +
@@ -209,7 +209,7 @@ export function createBashTool(cwd, options) {
         parameters: bashSchema,
         execute: async (_toolCallId, { command, timeout: explicitTimeout, connections }, signal, onUpdate, ctx) => {
             assertShellPolicy(command, ctx);
-            const timeout = explicitTimeout ?? 30;
+            const timeout = explicitTimeout ?? 60;
             const resolvedCommand = commandPrefix ? `${commandPrefix}\n${command}` : command;
             // Resolve connection credentials into env vars for this subprocess only
             let connectionEnv;

package/dist/app/tools/execute-code/index.d.ts

@@ -14,6 +14,7 @@ export type ExecuteCodeFactoryOptions = {
 } | {
     platform: 'mog';
     pool: SheetEnginePool;
+    approval?: ApprovalGate<ExcelApprovalPayload>;
 };
 export type ExecuteCodeTool = ReturnType<typeof createExcelExecTool> | ReturnType<typeof createSheetExecTool>;
 /**

package/dist/app/tools/execute-code/index.js

@@ -13,7 +13,9 @@ export function createExecuteCodeTool(options) {
             }
             return createExcelExecTool(options.httpPort, options.approval, options.observability);
         case 'mog':
-            return createSheetExecTool(options.pool);
+            return options.approval
+                ? createSheetExecTool(options.pool, options.approval)
+                : createSheetExecTool(options.pool);
     }
 }
 //# sourceMappingURL=index.js.map

package/dist/app/tools/find-ignore-files.d.ts

@@ -0,0 +1,3 @@
+/** Find repository ignore files without traversing dependency or Git metadata directories. */
+export declare function collectGitignoreFiles(rootDir: string): string[];
+//# sourceMappingURL=find-ignore-files.d.ts.map

package/dist/app/tools/find-ignore-files.js

@@ -0,0 +1,33 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+const SKIPPED_DIRECTORIES = new Set(['.git', 'node_modules']);
+/** Find repository ignore files without traversing dependency or Git metadata directories. */
+export function collectGitignoreFiles(rootDir) {
+    const pendingDirectories = [rootDir];
+    const gitignoreFiles = [];
+    while (pendingDirectories.length > 0) {
+        const currentDir = pendingDirectories.pop();
+        if (!currentDir)
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!SKIPPED_DIRECTORIES.has(entry.name)) {
+                    pendingDirectories.push(join(currentDir, entry.name));
+                }
+                continue;
+            }
+            if (entry.name === '.gitignore' && (entry.isFile() || entry.isSymbolicLink())) {
+                gitignoreFiles.push(join(currentDir, entry.name));
+            }
+        }
+    }
+    return gitignoreFiles.sort();
+}
+//# sourceMappingURL=find-ignore-files.js.map

package/dist/app/tools/find.js

@@ -1,7 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { spawnSync } from 'child_process';
 import { existsSync } from 'fs';
-import { globSync } from 'glob';
 import path from 'path';
 import { resolveToCwd } from '../../shared/files/path-utils.js';
 import { FIND } from '../../tool-names.js';
@@ -9,6 +8,7 @@ import { ABORT_AGENT_MESSAGE } from '../../utils/abort.js';
 import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from '../../utils/truncate.js';
 import { enforceFilesystemPolicy } from '../permissions/filesystem-policy.js';
 import { requirePermissionPolicy } from '../permissions/require-policy.js';
+import { collectGitignoreFiles } from './find-ignore-files.js';
 import { ensureTool } from './tool-binaries.js';
 const findSchema = Type.Object({
     pattern: Type.String({
@@ -114,26 +114,7 @@ export function createFindTool(cwd, options) {
                             String(effectiveLimit)
                         ];
                         // Include .gitignore files
-                        const gitignoreFiles = new Set();
-                        const rootGitignore = path.join(searchPath, '.gitignore');
-                        if (existsSync(rootGitignore)) {
-                            gitignoreFiles.add(rootGitignore);
-                        }
-                        try {
-                            const nestedGitignores = globSync('**/.gitignore', {
-                                cwd: searchPath,
-                                dot: true,
-                                absolute: true,
-                                ignore: ['**/node_modules/**', '**/.git/**']
-                            });
-                            for (const file of nestedGitignores) {
-                                gitignoreFiles.add(file);
-                            }
-                        }
-                        catch {
-                            // Ignore glob errors
-                        }
-                        for (const gitignorePath of gitignoreFiles) {
+                        for (const gitignorePath of collectGitignoreFiles(searchPath)) {
                             args.push('--ignore-file', gitignorePath);
                         }
                         args.push(pattern, searchPath);

package/dist/app/tools/llm-analysis.js

@@ -224,8 +224,6 @@ export function createLlmAnalysisTool() {
                 text = await extCtx.shortcutLlmProxy.collectText({
                     model: MODELS[selectedModel],
                     messages,
-                    effort_level: 'low',
-                    thinking_type: 'off',
                     llmOperation: 'llm_analysis'
                 }, { signal });
             }

package/dist/app/tools/refresh-context.d.ts

@@ -12,7 +12,7 @@ declare const schema: import("@sinclair/typebox").TObject<{
     query: import("@sinclair/typebox").TString;
     progressFolder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     model: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    thinkingLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"minimal" | "low" | "medium" | "high" | "xhigh" | "off">[]>>;
+    thinkingLevel: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">[]>>;
 }>;
 /** Build the `refresh_context` tool that schedules a fresh session for autonomous workflows. */
 export declare function createRefreshContextTool(session: () => AgentSession): ToolDefinition<typeof schema>;

package/dist/app/tools/session-settings/update-session-settings.js

@@ -16,7 +16,7 @@ const schema = Type.Object({
         description: 'User-requested model to use for subsequent turns. Use provider/model-id, or a bare exact model id if unambiguous.'
     })),
     thinking_level: Type.Optional(Type.String({
-        description: 'User-requested thinking level for subsequent turns: off, minimal, low, medium, high, or xhigh.'
+        description: 'User-requested thinking level for subsequent turns: off, minimal, low, medium, high, xhigh, or max.'
     }))
 });
 function textResult(text, isError = false) {
@@ -50,7 +50,7 @@ export function createUpdateSessionSettingsTool(session) {
             let targetThinking;
             if (requestedThinking !== undefined) {
                 if (!isValidThinkingLevel(requestedThinking)) {
-                    return textResult(`Invalid thinking_level "${requestedThinking}". Allowed: off, minimal, low, medium, high, xhigh.`, true);
+                    return textResult(`Invalid thinking_level "${requestedThinking}". Allowed: off, minimal, low, medium, high, xhigh, max.`, true);
                 }
                 const availableThinking = getAvailableThinkingLevels(targetModel);
                 if (!availableThinking.includes(requestedThinking)) {