shortcutxl 0.3.76 → 0.3.78

package/dist/app/tools/switch-mode.js

@@ -15,13 +15,13 @@ import { readFile } from 'node:fs/promises';
 import { MODE } from '../../mode-names.js';
 import { ACTION_SWITCH_MODE, INSTALLATION_SWITCH_MODE, PLAN_SWITCH_MODE } from '../../tool-names.js';
 import { APPROVAL } from '../approvals/types.js';
-import { getMode } from '../modes/index.js';
+import { getModeMetadata } from '../modes/metadata.js';
 import { switchMode } from '../modes/switch-mode.js';
 function buildDescription(sourceModeName, allowedTargets) {
     const modeList = allowedTargets.length > 0
         ? allowedTargets
             .map((modeName) => {
-            const mode = getMode(modeName);
+            const mode = getModeMetadata(modeName);
             return `- **${modeName}**: ${mode?.description ?? ''}`;
         })
             .join('\n')

package/dist/app/tools/take-screenshot.js

@@ -96,8 +96,6 @@ async function defaultAnalyzeWithVisionLLM(screenshots, query, model, shortcutLl
             model,
             messages,
             max_tokens: SCREENSHOT_LLM_MAX_TOKENS,
-            effort_level: 'low',
-            thinking_type: 'off',
             llmOperation: 'screenshot'
         }, { signal: signal ?? AbortSignal.timeout(SCREENSHOT_LLM_TIMEOUT_MS) });
     }

package/dist/app/tools/task/runner.js

@@ -189,8 +189,7 @@ export async function runTaskSubagent(options) {
         getTools: () => childTools,
         permissionPolicy: context.permissionPolicy,
         sessionState: new SessionState(),
-        approvalGrants: undefined,
-        subagentSpawnGrant: undefined
+        approvalGrants: undefined
     };
     const usage = emptyTaskUsage();
     const observedToolCalls = [];

package/dist/app/tools/task/task.d.ts

@@ -12,13 +12,11 @@ import type { ToolDefinition } from '../../../core/core-types.js';
 import { type RuntimePermissionPolicy } from '../../../core/permission-policy.js';
 import { type TaskManager } from './manager.js';
 import { type TaskSubagentResult } from './types.js';
-/** Derive the subagent's permission policy from the parent policy and approval flags. */
+/** Derive a non-widening subagent policy from the parent policy and child tools. */
 export declare function buildInheritedSubagentPermissionPolicy(input: {
     parentPolicy: RuntimePermissionPolicy;
     childToolNames: readonly string[];
-    taskCwd: string;
     persistentApprovals: RuntimePermissionPolicy['filesystem']['persistentApprovals'];
-    fullWorker?: boolean;
 }): RuntimePermissionPolicy;
 /** Pick the most informative error string from a subagent result for display. */
 export declare function getSubagentDisplayError(result: Pick<TaskSubagentResult, 'errorMessage' | 'text'>): string;

package/dist/app/tools/task/task.js

@@ -60,10 +60,6 @@ function getInheritedFilesystemGrants(ctx) {
     }
     return Array.from(deduped.values());
 }
-/** Combine the parent's workspace roots with the subagent's working directory. */
-function getInheritedWorkspaceRoots(permissionPolicy, taskCwd) {
-    return Array.from(new Set([...permissionPolicy.filesystem.workspaceRoots, taskCwd]));
-}
 /** Compute the capability flags implied by a subagent's declared tool list. */
 function getChildCapabilities(childToolNames) {
     const declaredToolNames = [...new Set(childToolNames)];
@@ -78,48 +74,35 @@ function getChildCapabilities(childToolNames) {
         subagents: hasCapability(declaredCapabilityIds, RUNTIME_CAPABILITY.SUBAGENT_SPAWN)
     };
 }
-/** Derive the subagent's permission policy from the parent policy and approval flags. */
+/** Derive a non-widening subagent policy from the parent policy and child tools. */
 export function buildInheritedSubagentPermissionPolicy(input) {
     const capabilities = getChildCapabilities(input.childToolNames);
-    const fullWorker = input.fullWorker === true;
     return {
         modeName: undefined,
-        dangerouslySkipRuntimePermissions: input.parentPolicy.dangerouslySkipRuntimePermissions || fullWorker,
+        dangerouslySkipRuntimePermissions: input.parentPolicy.dangerouslySkipRuntimePermissions,
         declaredToolNames: capabilities.declaredToolNames,
         declaredCapabilityIds: capabilities.declaredCapabilityIds,
         filesystem: {
-            workspaceRoots: getInheritedWorkspaceRoots(input.parentPolicy, input.taskCwd),
+            workspaceRoots: [...input.parentPolicy.filesystem.workspaceRoots],
             persistentApprovals: [...input.persistentApprovals],
             defaultReadScope: !capabilities.filesystemRead
                 ? 'none'
-                : fullWorker
-                    ? 'unrestricted'
-                    : input.parentPolicy.filesystem.defaultReadScope,
+                : input.parentPolicy.filesystem.defaultReadScope,
             defaultWriteScope: !capabilities.filesystemWrite
                 ? 'none'
-                : fullWorker
-                    ? 'unrestricted'
-                    : input.parentPolicy.filesystem.defaultWriteScope,
-            requireApprovalOutsideWorkspace: fullWorker
-                ? false
-                : input.parentPolicy.filesystem.requireApprovalOutsideWorkspace
+                : input.parentPolicy.filesystem.defaultWriteScope,
+            requireApprovalOutsideWorkspace: input.parentPolicy.filesystem.requireApprovalOutsideWorkspace
         },
         shell: {
-            enabled: capabilities.shell && (fullWorker || input.parentPolicy.shell.enabled),
-            mutationBehavior: !capabilities.shell
-                ? 'deny'
-                : fullWorker
-                    ? 'allow'
-                    : input.parentPolicy.shell.mutationBehavior
+            enabled: capabilities.shell && input.parentPolicy.shell.enabled,
+            mutationBehavior: !capabilities.shell ? 'deny' : input.parentPolicy.shell.mutationBehavior
         },
         spreadsheet: {
-            enabled: capabilities.spreadsheet && (fullWorker || input.parentPolicy.spreadsheet.enabled),
+            enabled: capabilities.spreadsheet && input.parentPolicy.spreadsheet.enabled,
             mutationBehavior: !capabilities.spreadsheet
                 ? 'deny'
-                : fullWorker
-                    ? 'require_approval'
-                    : input.parentPolicy.spreadsheet.mutationBehavior,
-            allowHeadlessApproval: fullWorker || input.parentPolicy.spreadsheet.allowHeadlessApproval
+                : input.parentPolicy.spreadsheet.mutationBehavior,
+            allowHeadlessApproval: input.parentPolicy.spreadsheet.allowHeadlessApproval
         },
         subagents: {
             enabled: capabilities.subagents && input.parentPolicy.subagents.enabled,
@@ -162,16 +145,19 @@ function buildSchema(excludeSubagents) {
 }
 /** Build the child runtime tool catalog by replacing the task tool with a scoped clone. */
 export function buildChildRuntimeTools(tools, options) {
-    return tools.map((tool) => tool.name === TASK
-        ? createTaskTool({
+    return tools.map((tool) => {
+        if (tool.name !== TASK)
+            return tool;
+        const childTaskTool = createTaskTool({
             cwd: options.cwd,
             excludeSubagents: options.excludeSubagents ? [...options.excludeSubagents] : undefined,
             getRuntimeTools: options.getRuntimeTools,
             notifyParent: options.notifyParent,
             taskManager: options.taskManager,
             disableMemory: options.disableMemory
-        })
-        : tool);
+        });
+        return childTaskTool;
+    });
 }
 /** Return any declared tool names that are missing from the runtime tool catalog. */
 function getMissingDeclaredTools(declaredToolNames, runtimeTools) {
@@ -190,9 +176,7 @@ export function createTaskTool(options = {}) {
         parameters: schema,
         async execute(toolCallId, params, signal, onUpdate, ctx) {
             const { subagent_type, name, query: rawQuery, query_file: queryFile, model: modelOverride, run_in_background } = params;
-            // A spawn-approval grant can force background mode regardless of what
-            // the model asked for; otherwise honor the LLM's run_in_background flag.
-            const effectiveRunInBackground = ctx?.subagentSpawnGrant?.runInBackground ?? run_in_background === true;
+            const effectiveRunInBackground = run_in_background === true;
             // Look up agent config
             const agentConfig = getSubagent(subagent_type);
             if (!agentConfig) {
@@ -266,14 +250,10 @@ export function createTaskTool(options = {}) {
             const modelInfo = extCtx.modelRegistry.find(modelProvider, modelId);
             const contextWindow = modelInfo?.contextWindow ?? 0;
             const inheritedFilesystemGrants = getInheritedFilesystemGrants(ctx);
-            const fullWorkerChild = permissionPolicy.dangerouslySkipRuntimePermissions ||
-                ctx?.subagentSpawnGrant?.fullWorker === true;
             const inheritedPermissionPolicy = buildInheritedSubagentPermissionPolicy({
                 parentPolicy: permissionPolicy,
                 childToolNames: effectiveConfig.tools,
-                taskCwd,
-                persistentApprovals: inheritedFilesystemGrants,
-                fullWorker: fullWorkerChild
+                persistentApprovals: inheritedFilesystemGrants
             });
             const timeoutMs = (agentConfig.timeoutSeconds ?? DEFAULT_SUBAGENT_TIMEOUT_SECONDS) * 1000;
             const abortController = new AbortController();

package/dist/app/tools/web-search.js

@@ -174,7 +174,7 @@ function createStartRateLimiter(ops) {
         await waitForStartSlot();
     };
 }
-async function requestWebSearchResult(baseUrl, apiKey, query, outputSchema, ops, signal) {
+async function requestWebSearchResult(baseUrl, apiKey, query, outputSchema, attribution, ops, signal) {
     // Mirrors the embedded exa_web_search route call; api-v1 owns the Exa key and
     // forwards outputSchema to Exa when present.
     const response = await ops.fetch(`${baseUrl}${SHORTCUT_API_ENDPOINTS.webSearch}`, {
@@ -182,6 +182,10 @@ async function requestWebSearchResult(baseUrl, apiKey, query, outputSchema, ops,
         headers: {
             'Content-Type': 'application/json',
             Authorization: `Bearer ${apiKey}`,
+            'X-Client-Platform': 'shortcutxl',
+            ...(attribution.userMessageId ? { 'X-Turn-Id': attribution.userMessageId } : {}),
+            ...(attribution.conversationId ? { 'X-Session-Id': attribution.conversationId } : {}),
+            ...(attribution.agentRunId ? { 'X-Agent-Run-Id': attribution.agentRunId } : {}),
             'User-AgentController': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`
         },
         body: JSON.stringify({
@@ -225,6 +229,12 @@ export function createWebSearchTool(baseUrl = SHORTCUT_API_URL, options) {
             if (!apiKey) {
                 throw new Error('Not authenticated. Please log in first.');
             }
+            const conversationId = extCtx?.sessionManager.getSessionId();
+            const attribution = {
+                ...(extCtx?.userMessageId ? { userMessageId: extCtx.userMessageId } : {}),
+                ...(conversationId ? { conversationId } : {}),
+                ...(extCtx?.continuationRunId ? { agentRunId: extCtx.continuationRunId } : {})
+            };
             const queries = await readQueries(normalizedInput, ops);
             if (queries.length === 0) {
                 throw new Error('Web search did not receive any non-empty queries.');
@@ -256,7 +266,7 @@ export function createWebSearchTool(baseUrl = SHORTCUT_API_URL, options) {
             await mapWithMaxInFlight(queries, MAX_IN_FLIGHT_WEB_SEARCH_REQUESTS, waitForStartSlot, async (query) => {
                 let result;
                 try {
-                    result = attachQuery(await requestWebSearchResult(baseUrl, apiKey, query, normalizedInput.outputSchema, ops, signal), query);
+                    result = attachQuery(await requestWebSearchResult(baseUrl, apiKey, query, normalizedInput.outputSchema, attribution, ops, signal), query);
                 }
                 catch (error) {
                     result = {

package/dist/autocomplete/core.d.ts

@@ -0,0 +1,33 @@
+export interface AutocompleteCoreItem {
+  value: string;
+  label: string;
+  description?: string;
+}
+
+export interface PathPrefix {
+  rawPrefix: string;
+  isAtPrefix: boolean;
+  isQuotedPrefix: boolean;
+}
+
+export interface CompletionResult {
+  lines: string[];
+  cursorLine: number;
+  cursorCol: number;
+}
+
+export declare function findLastDelimiter(text: string): number;
+export declare function extractQuotedPrefix(text: string): string | null;
+export declare function extractAtPrefix(text: string): string | null;
+export declare function parsePathPrefix(prefix: string): PathPrefix;
+export declare function buildCompletionValue(
+  path: string,
+  options: { isAtPrefix: boolean; isQuotedPrefix: boolean }
+): string;
+export declare function applyAutocompleteCompletion(
+  lines: string[],
+  cursorLine: number,
+  cursorCol: number,
+  item: AutocompleteCoreItem,
+  prefix: string
+): CompletionResult;

package/dist/autocomplete/core.js

@@ -0,0 +1,113 @@
+const PATH_DELIMITERS = new Set([' ', '\t', '"', "'", '=']);
+
+export function findLastDelimiter(text) {
+  for (let i = text.length - 1; i >= 0; i -= 1) {
+    if (PATH_DELIMITERS.has(text[i] ?? '')) return i;
+  }
+  return -1;
+}
+
+function findUnclosedQuoteStart(text) {
+  let inQuotes = false;
+  let quoteStart = -1;
+  for (let i = 0; i < text.length; i += 1) {
+    if (text[i] === '"') {
+      inQuotes = !inQuotes;
+      if (inQuotes) quoteStart = i;
+    }
+  }
+  return inQuotes ? quoteStart : null;
+}
+
+function isTokenStart(text, index) {
+  return index === 0 || PATH_DELIMITERS.has(text[index - 1] ?? '');
+}
+
+export function extractQuotedPrefix(text) {
+  const quoteStart = findUnclosedQuoteStart(text);
+  if (quoteStart === null) return null;
+  if (quoteStart > 0 && text[quoteStart - 1] === '@') {
+    if (!isTokenStart(text, quoteStart - 1)) return null;
+    return text.slice(quoteStart - 1);
+  }
+  if (!isTokenStart(text, quoteStart)) return null;
+  return text.slice(quoteStart);
+}
+
+export function extractAtPrefix(text) {
+  const quotedPrefix = extractQuotedPrefix(text);
+  if (quotedPrefix?.startsWith('@"')) return quotedPrefix;
+  const lastDelimiterIndex = findLastDelimiter(text);
+  const tokenStart = lastDelimiterIndex === -1 ? 0 : lastDelimiterIndex + 1;
+  return text[tokenStart] === '@' ? text.slice(tokenStart) : null;
+}
+
+export function parsePathPrefix(prefix) {
+  if (prefix.startsWith('@"')) {
+    return { rawPrefix: prefix.slice(2), isAtPrefix: true, isQuotedPrefix: true };
+  }
+  if (prefix.startsWith('"')) {
+    return { rawPrefix: prefix.slice(1), isAtPrefix: false, isQuotedPrefix: true };
+  }
+  if (prefix.startsWith('@')) {
+    return { rawPrefix: prefix.slice(1), isAtPrefix: true, isQuotedPrefix: false };
+  }
+  return { rawPrefix: prefix, isAtPrefix: false, isQuotedPrefix: false };
+}
+
+export function buildCompletionValue(path, options) {
+  const needsQuotes = options.isQuotedPrefix || path.includes(' ');
+  const prefix = options.isAtPrefix ? '@' : '';
+  return needsQuotes ? `${prefix}"${path}"` : `${prefix}${path}`;
+}
+
+/** Browser-safe completion semantics shared by the TUI and native React composer. */
+export function applyAutocompleteCompletion(lines, cursorLine, cursorCol, item, prefix) {
+  const currentLine = lines[cursorLine] || '';
+  const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+  const afterCursor = currentLine.slice(cursorCol);
+  const isQuotedPrefix = prefix.startsWith('"') || prefix.startsWith('@"');
+  const adjustedAfterCursor =
+    isQuotedPrefix && item.value.endsWith('"') && afterCursor.startsWith('"')
+      ? afterCursor.slice(1)
+      : afterCursor;
+  const isSlashCommand =
+    prefix.startsWith('/') &&
+    !prefix.slice(1).includes('/') &&
+    (beforePrefix.trim() === '' || item.value.startsWith('skill:'));
+
+  if (isSlashCommand) {
+    const newLines = [...lines];
+    newLines[cursorLine] = `${beforePrefix}/${item.value} ${adjustedAfterCursor}`;
+    return {
+      lines: newLines,
+      cursorLine,
+      cursorCol: beforePrefix.length + item.value.length + 2
+    };
+  }
+
+  if (prefix.startsWith('@')) {
+    const isDirectory = item.label.endsWith('/');
+    const suffix = isDirectory ? '' : ' ';
+    const newLines = [...lines];
+    newLines[cursorLine] = `${beforePrefix + item.value}${suffix}${adjustedAfterCursor}`;
+    const cursorOffset =
+      isDirectory && item.value.endsWith('"') ? item.value.length - 1 : item.value.length;
+    return {
+      lines: newLines,
+      cursorLine,
+      cursorCol: beforePrefix.length + cursorOffset + suffix.length
+    };
+  }
+
+  const newLines = [...lines];
+  newLines[cursorLine] = beforePrefix + item.value + adjustedAfterCursor;
+  const isDirectory = item.label.endsWith('/');
+  const cursorOffset =
+    isDirectory && item.value.endsWith('"') ? item.value.length - 1 : item.value.length;
+  return {
+    lines: newLines,
+    cursorLine,
+    cursorCol: beforePrefix.length + cursorOffset
+  };
+}

package/dist/{tui → autocomplete}/fuzzy.d.ts

@@ -17,4 +17,3 @@ export declare function fuzzyFilter<T>(
   query: string,
   getText: (item: T) => string
 ): T[];
-//# sourceMappingURL=fuzzy.d.ts.map

package/dist/{tui → autocomplete}/fuzzy.js

@@ -102,4 +102,3 @@ export function fuzzyFilter(items, query, getText) {
   results.sort((a, b) => a.totalScore - b.totalScore);
   return results.map((r) => r.item);
 }
-//# sourceMappingURL=fuzzy.js.map

package/dist/{tui/autocomplete.d.ts → autocomplete/index.d.ts}

@@ -78,4 +78,3 @@ export declare class CombinedAutocompleteProvider implements AutocompleteProvide
   } | null;
   shouldTriggerFileCompletion(lines: string[], cursorLine: number, cursorCol: number): boolean;
 }
-//# sourceMappingURL=autocomplete.d.ts.map

package/dist/{tui/autocomplete.js → autocomplete/index.js}

@@ -2,71 +2,16 @@ import { spawnSync } from 'child_process';
 import { readdirSync, statSync } from 'fs';
 import { homedir } from 'os';
 import { basename, dirname, join } from 'path';
+import {
+  applyAutocompleteCompletion,
+  buildCompletionValue,
+  extractAtPrefix,
+  extractQuotedPrefix,
+  findLastDelimiter,
+  parsePathPrefix
+} from './core.js';
 import { fuzzyFilter } from './fuzzy.js';
 import { extractInlineSkillAutocompleteToken } from './skill-autocomplete.js';
-const PATH_DELIMITERS = new Set([' ', '\t', '"', "'", '=']);
-function findLastDelimiter(text) {
-  for (let i = text.length - 1; i >= 0; i -= 1) {
-    if (PATH_DELIMITERS.has(text[i] ?? '')) {
-      return i;
-    }
-  }
-  return -1;
-}
-function findUnclosedQuoteStart(text) {
-  let inQuotes = false;
-  let quoteStart = -1;
-  for (let i = 0; i < text.length; i += 1) {
-    if (text[i] === '"') {
-      inQuotes = !inQuotes;
-      if (inQuotes) {
-        quoteStart = i;
-      }
-    }
-  }
-  return inQuotes ? quoteStart : null;
-}
-function isTokenStart(text, index) {
-  return index === 0 || PATH_DELIMITERS.has(text[index - 1] ?? '');
-}
-function extractQuotedPrefix(text) {
-  const quoteStart = findUnclosedQuoteStart(text);
-  if (quoteStart === null) {
-    return null;
-  }
-  if (quoteStart > 0 && text[quoteStart - 1] === '@') {
-    if (!isTokenStart(text, quoteStart - 1)) {
-      return null;
-    }
-    return text.slice(quoteStart - 1);
-  }
-  if (!isTokenStart(text, quoteStart)) {
-    return null;
-  }
-  return text.slice(quoteStart);
-}
-function parsePathPrefix(prefix) {
-  if (prefix.startsWith('@"')) {
-    return { rawPrefix: prefix.slice(2), isAtPrefix: true, isQuotedPrefix: true };
-  }
-  if (prefix.startsWith('"')) {
-    return { rawPrefix: prefix.slice(1), isAtPrefix: false, isQuotedPrefix: true };
-  }
-  if (prefix.startsWith('@')) {
-    return { rawPrefix: prefix.slice(1), isAtPrefix: true, isQuotedPrefix: false };
-  }
-  return { rawPrefix: prefix, isAtPrefix: false, isQuotedPrefix: false };
-}
-function buildCompletionValue(path, options) {
-  const needsQuotes = options.isQuotedPrefix || path.includes(' ');
-  const prefix = options.isAtPrefix ? '@' : '';
-  if (!needsQuotes) {
-    return `${prefix}${path}`;
-  }
-  const openQuote = `${prefix}"`;
-  const closeQuote = '"';
-  return `${openQuote}${path}${closeQuote}`;
-}
 // Use fd to walk directory tree (fast, respects .gitignore)
 function walkDirectoryWithFd(baseDir, fdPath, query, maxResults) {
   const args = [
@@ -99,10 +44,11 @@ function walkDirectoryWithFd(baseDir, fdPath, query, maxResults) {
   if (result.status !== 0 || !result.stdout) {
     return [];
   }
-  const lines = result.stdout.trim().split('\n').filter(Boolean);
+  const lines = result.stdout.trim().split(/\r?\n/).filter(Boolean);
   const results = [];
   for (const line of lines) {
-    const normalizedPath = line.endsWith('/') ? line.slice(0, -1) : line;
+    const posixPath = line.replaceAll('\\', '/');
+    const normalizedPath = posixPath.endsWith('/') ? posixPath.slice(0, -1) : posixPath;
     if (
       normalizedPath === '.git' ||
       normalizedPath.startsWith('.git/') ||
@@ -111,14 +57,58 @@ function walkDirectoryWithFd(baseDir, fdPath, query, maxResults) {
       continue;
     }
     // fd outputs directories with trailing /
-    const isDirectory = line.endsWith('/');
+    const isDirectory = posixPath.endsWith('/');
     results.push({
-      path: line,
+      path: posixPath,
       isDirectory
     });
   }
   return results;
 }
+// Keep autocomplete available when the shared tool bootstrap cannot provide fd, such as in
+// offline mode or on an unsupported platform.
+function walkDirectoryWithoutFd(baseDir, query, maxResults) {
+  const normalizedQuery = query.toLowerCase();
+  const results = [];
+  const pendingDirectories = [''];
+  let visitedEntries = 0;
+  const maxVisitedEntries = 20_000;
+
+  while (
+    pendingDirectories.length > 0 &&
+    results.length < maxResults &&
+    visitedEntries < maxVisitedEntries
+  ) {
+    const relativeDirectory = pendingDirectories.shift() ?? '';
+    const directory = relativeDirectory ? join(baseDir, relativeDirectory) : baseDir;
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    for (const entry of entries) {
+      visitedEntries++;
+      if (entry.name === '.git' || entry.name === 'node_modules') continue;
+      const relativePath = relativeDirectory ? join(relativeDirectory, entry.name) : entry.name;
+      const displayPath = relativePath.split('\\').join('/');
+      const isDirectory = entry.isDirectory();
+      if (isDirectory) pendingDirectories.push(relativePath);
+      if (!normalizedQuery || displayPath.toLowerCase().includes(normalizedQuery)) {
+        results.push({ path: isDirectory ? `${displayPath}/` : displayPath, isDirectory });
+        if (results.length >= maxResults) break;
+      }
+      if (visitedEntries >= maxVisitedEntries) break;
+    }
+  }
+
+  return results;
+}
 // Combined provider that handles both slash commands and file paths
 export class CombinedAutocompleteProvider {
   commands;
@@ -253,94 +243,11 @@ export class CombinedAutocompleteProvider {
     return null;
   }
   applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-    const currentLine = lines[cursorLine] || '';
-    const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
-    const afterCursor = currentLine.slice(cursorCol);
-    const isQuotedPrefix = prefix.startsWith('"') || prefix.startsWith('@"');
-    const hasLeadingQuoteAfterCursor = afterCursor.startsWith('"');
-    const hasTrailingQuoteInItem = item.value.endsWith('"');
-    const adjustedAfterCursor =
-      isQuotedPrefix && hasTrailingQuoteInItem && hasLeadingQuoteAfterCursor
-        ? afterCursor.slice(1)
-        : afterCursor;
-    // Check if we're completing a slash command (prefix starts with "/" but NOT a file path)
-    // Slash commands are at the start of the line and don't contain path separators after the first /
-    const isSlashCommand =
-      prefix.startsWith('/') &&
-      !prefix.slice(1).includes('/') &&
-      (beforePrefix.trim() === '' || item.value.startsWith('skill:'));
-    if (isSlashCommand) {
-      // This is a command name completion
-      const newLine = `${beforePrefix}/${item.value} ${adjustedAfterCursor}`;
-      const newLines = [...lines];
-      newLines[cursorLine] = newLine;
-      return {
-        lines: newLines,
-        cursorLine,
-        cursorCol: beforePrefix.length + item.value.length + 2 // +2 for "/" and space
-      };
-    }
-    // Check if we're completing a file attachment (prefix starts with "@")
-    if (prefix.startsWith('@')) {
-      // This is a file attachment completion
-      // Don't add space after directories so user can continue autocompleting
-      const isDirectory = item.label.endsWith('/');
-      const suffix = isDirectory ? '' : ' ';
-      const newLine = `${beforePrefix + item.value}${suffix}${adjustedAfterCursor}`;
-      const newLines = [...lines];
-      newLines[cursorLine] = newLine;
-      const hasTrailingQuote = item.value.endsWith('"');
-      const cursorOffset =
-        isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
-      return {
-        lines: newLines,
-        cursorLine,
-        cursorCol: beforePrefix.length + cursorOffset + suffix.length
-      };
-    }
-    // Check if we're in a slash command context (beforePrefix contains "/command ")
-    const textBeforeCursor = currentLine.slice(0, cursorCol);
-    if (textBeforeCursor.includes('/') && textBeforeCursor.includes(' ')) {
-      // This is likely a command argument completion
-      const newLine = beforePrefix + item.value + adjustedAfterCursor;
-      const newLines = [...lines];
-      newLines[cursorLine] = newLine;
-      const isDirectory = item.label.endsWith('/');
-      const hasTrailingQuote = item.value.endsWith('"');
-      const cursorOffset =
-        isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
-      return {
-        lines: newLines,
-        cursorLine,
-        cursorCol: beforePrefix.length + cursorOffset
-      };
-    }
-    // For file paths, complete the path
-    const newLine = beforePrefix + item.value + adjustedAfterCursor;
-    const newLines = [...lines];
-    newLines[cursorLine] = newLine;
-    const isDirectory = item.label.endsWith('/');
-    const hasTrailingQuote = item.value.endsWith('"');
-    const cursorOffset =
-      isDirectory && hasTrailingQuote ? item.value.length - 1 : item.value.length;
-    return {
-      lines: newLines,
-      cursorLine,
-      cursorCol: beforePrefix.length + cursorOffset
-    };
+    return applyAutocompleteCompletion(lines, cursorLine, cursorCol, item, prefix);
   }
   // Extract @ prefix for fuzzy file suggestions
   extractAtPrefix(text) {
-    const quotedPrefix = extractQuotedPrefix(text);
-    if (quotedPrefix?.startsWith('@"')) {
-      return quotedPrefix;
-    }
-    const lastDelimiterIndex = findLastDelimiter(text);
-    const tokenStart = lastDelimiterIndex === -1 ? 0 : lastDelimiterIndex + 1;
-    if (text[tokenStart] === '@') {
-      return text.slice(tokenStart);
-    }
-    return null;
+    return extractAtPrefix(text);
   }
   // Extract a path-like prefix from the text before cursor
   extractPathPrefix(text, forceExtract = false) {
@@ -546,15 +453,13 @@ export class CombinedAutocompleteProvider {
   }
   // Fuzzy file search using fd (fast, respects .gitignore)
   getFuzzyFileSuggestions(query, options) {
-    if (!this.fdPath) {
-      // fd not available, return empty results
-      return [];
-    }
     try {
       const scopedQuery = this.resolveScopedFuzzyQuery(query);
       const fdBaseDir = scopedQuery?.baseDir ?? this.basePath;
       const fdQuery = scopedQuery?.query ?? query;
-      const entries = walkDirectoryWithFd(fdBaseDir, this.fdPath, fdQuery, 100);
+      const entries = this.fdPath
+        ? walkDirectoryWithFd(fdBaseDir, this.fdPath, fdQuery, 100)
+        : walkDirectoryWithoutFd(fdBaseDir, fdQuery, 100);
       // Score entries
       const scoredEntries = entries
         .map((entry) => ({
@@ -622,4 +527,3 @@ export class CombinedAutocompleteProvider {
     return true;
   }
 }
-//# sourceMappingURL=autocomplete.js.map

package/dist/cli/args.js

@@ -233,7 +233,7 @@ ${chalk.bold('Options:')}
   --session <path>               Use specific session file
   --session-dir <dir>            Directory for session storage and lookup
   --no-session                   Don't save session (ephemeral)
-  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
+  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh, max
   --extension, -e <path>         Load an extension file (can be used multiple times)
   --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
   --skill <path>                 Load a skill file or directory (can be used multiple times)