shortcutxl 0.3.50 → 0.3.52

package/CHANGELOG.md

@@ -1,4 +1,19 @@
-# Changelog
+# Changelog
+
+## [0.3.52]
+
+- **Team fast mode policy** - Fast Mode is now automatically disabled for team accounts, with a clear message when your team policy blocks it.
+- **Cleaner footer and shortcuts** - The footer now uses shorter model names, shows model/thinking hotkeys inline, and moves model cycling to `alt+p`, thinking to `alt+t`, and runtime permission bypass to `alt+r`.
+- **Copy selection hint** - Selecting transcript text now shows a `Ctrl+C to copy` hint while preserving the exact copied text.
+
+## [0.3.51]
+
+- **TUI rendering and text selection** - Improved TUI rendering, scrolling. Fixed text highlighting and selection for copy pastes.
+- **Agentic MCP setup** - Agents can now help set up MCP servers through `shortcut mcp add/list/get/login/logout/remove`, with clearer login, logs, and OAuth settings.
+- **User-requested session settings** - When asked, agents can inspect available models and thinking levels or apply your requested session change.
+- **Skill sync clarity** - Skill sync now shows startup differences plus per-file upload/download changes, source, and visibility.
+- **Fast mode toggle** - Fast Mode now shows in the footer and can be toggled with `alt+f` or `/fast`, with clearer availability warnings.
+- **Scrollable approvals** - Large approval and permission dialogs now scroll properly, including spreadsheet change tables in small terminals.
 
 ## [0.3.50]
 

package/dist/app/agent-session-runtime-adapter.d.ts

@@ -38,6 +38,7 @@ export interface CreateAgentSessionRuntimeAdapterOptions {
     approvalState?: AgentApprovalState;
     budgetLimits?: RuntimeBudgetLimits;
     enableToolSummaries?: boolean;
+    fastModeAllowed?: boolean;
     modeName?: string;
     model?: Model<Api>;
     observability?: RuntimeObservability;

package/dist/app/agent-session-runtime-adapter.js

@@ -211,6 +211,7 @@ export async function createAgentSessionRuntimeAdapter(options) {
         initialModeName: options.modeName,
         initialPermissionPolicy: options.permissionPolicy,
         modelRegistry,
+        fastModeAllowed: options.fastModeAllowed,
         extensionRunnerRef,
         prePromptContext: options.prePromptContext,
         budgetLimits: options.budgetLimits,

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

@@ -105,6 +105,7 @@ export interface AgentSessionConfig {
     initialPermissionPolicy?: RuntimePermissionPolicy;
     /** Model registry for API key resolution and model discovery */
     modelRegistry: AgentModelRegistry;
+    fastModeAllowed?: boolean;
     /** Mutable ref used by AgentController to access the current ExtensionRunner */
     extensionRunnerRef?: {
         current?: ExtensionRunner;
@@ -182,6 +183,7 @@ export declare class AgentSession {
     private _observability?;
     private _tools;
     private _models;
+    private _fastModeAllowed;
     private _extensions;
     private _compactionActions;
     private _compactionTriggerDeps;
@@ -261,6 +263,12 @@ export declare class AgentSession {
     get model(): Model<any> | undefined;
     /** Current thinking level */
     get thinkingLevel(): ThinkingLevel;
+    get isFastModeEnabled(): boolean;
+    get isFastModeAllowed(): boolean;
+    get isFastModeAvailable(): boolean;
+    setFastModeAllowed(allowed: boolean): void;
+    setFastModeEnabled(enabled: boolean): void;
+    toggleFastMode(): boolean;
     /** Whether agent is currently streaming a response */
     get isStreaming(): boolean;
     /** Current effective system prompt (includes any per-turn extension modifications) */

package/dist/app/agent-session.js

@@ -16,6 +16,7 @@ import { isContextOverflow } from '@mariozechner/pi-ai';
 import { SessionState } from '../core/session-state.js';
 import { createCompactionActions, createErrorRecoveryActions, triggerCompactionIfNeeded } from '../core/session/compaction-bridge.js';
 import { SessionCompaction } from '../core/session/session-compaction.js';
+import { isShortcutFastModeModel } from '../model-ids.js';
 import { formatFileUploadsContext, mergeFileUploads } from './file-uploads.js';
 import { expandPromptTemplate } from './resources/prompt-template-expansion.js';
 import { parseSkillBlock } from './resources/skill-block.js';
@@ -26,6 +27,7 @@ import { emitExtensionEvent } from './session/extension-emitter.js';
 import { ExtensionLifecycle } from './session/extension-lifecycle.js';
 import { ModelManager } from './session/model-manager.js';
 import { resolvePendingRefreshOverride } from './session/pending-refresh-overrides.js';
+import { formatRuntimePermissionBypassReminder } from './session/permission-context.js';
 import { PersistenceHandler } from './session/persistence-handler.js';
 import { assertNotExtensionCommand, buildMessageContent, normalizeUserContent, tryExtensionCommand } from './session/prompt-pipeline.js';
 import { QueueTracker } from './session/queue-tracker.js';
@@ -35,6 +37,7 @@ import { executeNewSession, executeSwitchSession } from './session/session-lifec
 import { getAvailableThinkingLevels, supportsThinking, supportsXhighThinking } from './session/session-models.js';
 import { computeContextUsage, computeSessionStats } from './session/session-stats.js';
 import { expandSkillCommand } from './session/skill-expansion.js';
+import { formatSystemReminderContext } from './session/system-reminder-context.js';
 import { ToolRegistry } from './session/tool-registry.js';
 import { ToolSummaryEmitter } from './session/tool-summary-emitter.js';
 import { isToolSummaryEligible } from './session/tool-summary-policy.js';
@@ -107,6 +110,7 @@ export class AgentSession {
     _tools;
     // Model manager — model switching, cycling, thinking level
     _models;
+    _fastModeAllowed = true;
     // Extension lifecycle — owns extension runner, bindings, reload
     _extensions;
     // Bridge objects for compaction/recovery/budget subsystems
@@ -125,6 +129,7 @@ export class AgentSession {
         this._prePromptContext = config.prePromptContext;
         this._budgetLimits = config.budgetLimits;
         this._observability = config.observability;
+        this._fastModeAllowed = config.fastModeAllowed ?? true;
         this._summaryEmitter = new ToolSummaryEmitter({
             enabled: config.enableToolSummaries ?? true,
             isFeatureEnabled: () => this.settingsManager.getToolSummariesEnabled(),
@@ -582,6 +587,32 @@ export class AgentSession {
     get thinkingLevel() {
         return this.agent.state.thinkingLevel;
     }
+    get isFastModeEnabled() {
+        return this.isFastModeAvailable && this.agent.speed === 'fast';
+    }
+    get isFastModeAllowed() {
+        return this._fastModeAllowed;
+    }
+    get isFastModeAvailable() {
+        return this._fastModeAllowed && isShortcutFastModeModel(this.model);
+    }
+    setFastModeAllowed(allowed) {
+        this._fastModeAllowed = allowed;
+        if (!allowed)
+            this.setFastModeEnabled(false);
+    }
+    setFastModeEnabled(enabled) {
+        this.agent.speed = enabled && this.isFastModeAvailable ? 'fast' : undefined;
+    }
+    toggleFastMode() {
+        if (!this.isFastModeAvailable) {
+            this.agent.speed = undefined;
+            return false;
+        }
+        const enabled = !this.isFastModeEnabled;
+        this.setFastModeEnabled(enabled);
+        return enabled;
+    }
     /** Whether agent is currently streaming a response */
     get isStreaming() {
         return this.agent.state.isStreaming;
@@ -781,6 +812,25 @@ export class AgentSession {
         }
         // Build messages array (custom message if any, then user message)
         const messages = [];
+        this.lastPrePromptDetails = undefined;
+        const prePromptContextParts = [formatRuntimePermissionBypassReminder(this.permissionPolicy)];
+        let prePromptDetails;
+        if (this._prePromptContext) {
+            const ctx = await this._prePromptContext();
+            if (ctx) {
+                this.lastPrePromptDetails = ctx.details;
+                prePromptDetails = ctx.details;
+                prePromptContextParts.unshift(ctx.text);
+            }
+        }
+        messages.push({
+            role: 'custom',
+            customType: 'prePromptContext',
+            content: formatSystemReminderContext(prePromptContextParts),
+            display: false,
+            details: prePromptDetails,
+            timestamp: Date.now()
+        });
         // Add user message
         const userContent = [{ type: 'text', text: expandedText }];
         if (currentImages) {
@@ -791,21 +841,6 @@ export class AgentSession {
             content: userContent,
             timestamp: Date.now()
         });
-        this.lastPrePromptDetails = undefined;
-        if (this._prePromptContext) {
-            const ctx = await this._prePromptContext();
-            if (ctx) {
-                this.lastPrePromptDetails = ctx.details;
-                messages.push({
-                    role: 'custom',
-                    customType: 'prePromptContext',
-                    content: ctx.text,
-                    display: false,
-                    details: ctx.details,
-                    timestamp: Date.now()
-                });
-            }
-        }
         // Inject any pending "nextTurn" messages as context alongside the user message
         for (const msg of this._pendingNextTurnMessages) {
             messages.push(msg);
@@ -1149,11 +1184,16 @@ export class AgentSession {
     // =========================================================================
     /** Switch the session's active LLM to `model`, persisting the change. */
     async setModel(model) {
-        return this._models.setModel(model);
+        await this._models.setModel(model);
+        if (!this.isFastModeAvailable)
+            this.setFastModeEnabled(false);
     }
     /** Cycle to the next configured model and report the switch result. */
     async cycleModel(direction = 'forward') {
-        return this._models.cycleModel(direction);
+        const result = await this._models.cycleModel(direction);
+        if (!this.isFastModeAvailable)
+            this.setFastModeEnabled(false);
+        return result;
     }
     /** Set the model's reasoning/thinking level for subsequent turns. */
     setThinkingLevel(level) {

package/dist/app/approvals/types.d.ts

@@ -66,4 +66,9 @@ export interface TaskSpawnApprovalData {
     /** Launch mode requested by the tool call before user approval overrides. */
     requestedRunInBackground: boolean;
 }
+export interface SwitchModeApprovalData {
+    currentMode: string;
+    targetMode: string;
+    reason?: string;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/app/auth/auth-storage.js

@@ -10,12 +10,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'f
 import { dirname, join } from 'path';
 import lockfile from 'proper-lockfile';
 import { getAgentDir } from '../../config.js';
-/**
- * Shared lock options so sync and async locks always use the same lock path.
- * realpath: false ensures both create the same .lock directory on Windows,
- * where fs.realpath can normalize paths differently.
- */
-const LOCK_BASE_OPTIONS = { realpath: false };
+import { LOCK_BASE_OPTIONS, lockSyncWithRetries } from '../../shared/files/lock-utils.js';
 export class FileAuthStorageBackend {
     authPath;
     constructor(authPath = join(getAgentDir(), 'auth.json')) {
@@ -38,7 +33,7 @@ export class FileAuthStorageBackend {
         this.ensureFileExists();
         let release;
         try {
-            release = lockfile.lockSync(this.authPath, LOCK_BASE_OPTIONS);
+            release = lockSyncWithRetries(this.authPath);
             const current = existsSync(this.authPath) ? readFileSync(this.authPath, 'utf-8') : undefined;
             const { result, next } = fn(current);
             if (next !== undefined) {

package/dist/app/extensions/slash-commands.js

@@ -15,6 +15,7 @@ const ALL_BUILTIN_SLASH_COMMANDS = [
     // Model
     { name: 'model', description: 'Select model' },
     { name: 'thinking', description: 'Select thinking level' },
+    { name: 'fast', description: 'Toggle fast mode for subsequent turns' },
     { name: 'hide-thinking', description: 'Toggle visibility of thinking blocks' },
     // Checkpointing
     { name: 'resume', description: 'Resume a different session' },

package/dist/app/index.d.ts

@@ -48,9 +48,11 @@ export { readSkillProposalReviewSnapshot, type SkillProposalReviewSnapshot } fro
 export type { StartupInfoEntry } from './startup-info.js';
 export { downloadSkillsWithApproval } from './sync/skills-download.js';
 export type { SkillDownloadApprovalHandler, SkillDownloadApprovalRequest, SkillsDownloadResult } from './sync/skills-download.js';
+export { checkSkillsSyncStatus } from './sync/skills-status.js';
+export type { SkillSyncStatusItem, SkillsSyncStatus } from './sync/skills-status.js';
 export { uploadSkills } from './sync/skills-upload.js';
 export type { SkillUploadApprovalRequest, SkillsUploadResult } from './sync/skills-upload.js';
 export * from './tools/index.js';
-export { buildWorkbookPromptContext, fetchWorkbookConnectionState, formatWorkbookScopePromptContext } from './workbook-context/workbook-summary.js';
+export { buildWorkbookPromptContext, fetchWorkbookConnectionState, formatWorkbookScopeReminder } from './workbook-context/workbook-summary.js';
 export { SCOPE_UNSET, type WorkbookConnectionState, type WorkbookScopeDetails, type WorkbookScopeStateRef } from './workbook-scope.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/app/index.js

@@ -37,8 +37,9 @@ export { default as skillProposalsExtension } from './skill-proposals/extension.
 export { getSkillProposalRoots } from './skill-proposals/proposal-fs.js';
 export { readSkillProposalReviewSnapshot } from './skill-proposals/review.js';
 export { downloadSkillsWithApproval } from './sync/skills-download.js';
+export { checkSkillsSyncStatus } from './sync/skills-status.js';
 export { uploadSkills } from './sync/skills-upload.js';
 export * from './tools/index.js';
-export { buildWorkbookPromptContext, fetchWorkbookConnectionState, formatWorkbookScopePromptContext } from './workbook-context/workbook-summary.js';
+export { buildWorkbookPromptContext, fetchWorkbookConnectionState, formatWorkbookScopeReminder } from './workbook-context/workbook-summary.js';
 export { SCOPE_UNSET } from './workbook-scope.js';
 //# sourceMappingURL=index.js.map

package/dist/app/local/tools/execute-code/observability.d.ts

@@ -0,0 +1,4 @@
+import type { ShortcutClientLogger } from '../../../observability/index.js';
+import type { ExcelExecApprovalObservability } from './executor.js';
+export declare function createExecuteCodeApprovalObservability(clientLogger: ShortcutClientLogger): ExcelExecApprovalObservability;
+//# sourceMappingURL=observability.d.ts.map

package/dist/app/local/tools/execute-code/observability.js

@@ -0,0 +1,57 @@
+const TOOL_NAME = 'execute_code';
+export function createExecuteCodeApprovalObservability(clientLogger) {
+    return {
+        onRequested: (request) => {
+            clientLogger.info({
+                module: 'tool',
+                event: 'tool_approval_requested',
+                data: {
+                    tool_name: TOOL_NAME,
+                    approval_kind: request.payload.kind
+                }
+            });
+        },
+        onAccepted: (request, choice) => {
+            clientLogger.info({
+                module: 'tool',
+                event: 'tool_approval_accepted',
+                data: {
+                    tool_name: TOOL_NAME,
+                    approval_kind: request.payload.kind,
+                    accept_all: choice === 'Accept All'
+                }
+            });
+        },
+        onRejected: (request) => {
+            clientLogger.warn({
+                module: 'tool',
+                event: 'tool_approval_rejected',
+                data: {
+                    tool_name: TOOL_NAME,
+                    approval_kind: request.payload.kind
+                }
+            });
+        },
+        onReverted: (request) => {
+            clientLogger.info({
+                module: 'tool',
+                event: 'tool_approval_reverted',
+                data: {
+                    tool_name: TOOL_NAME,
+                    approval_kind: request.payload.kind
+                }
+            });
+        },
+        onRevertFailed: (request) => {
+            clientLogger.error({
+                module: 'tool',
+                event: 'tool_approval_revert_failed',
+                data: {
+                    tool_name: TOOL_NAME,
+                    approval_kind: request.payload.kind
+                }
+            });
+        }
+    };
+}
+//# sourceMappingURL=observability.js.map

package/dist/app/mcp/auth-status.d.ts

@@ -1,4 +1,12 @@
 import type { AuthStorage } from '../auth/auth-storage.js';
+import type { McpOAuthStore } from './oauth-state-store.js';
 import { type McpAuthStatus, type McpServerConfig } from './types.js';
-export declare function getMcpAuthStatus(serverName: string, config: McpServerConfig, authStorage?: AuthStorage): Promise<McpAuthStatus>;
+export type McpAuthDiscoveryMode = 'never' | 'cached' | 'network';
+export interface ResolveMcpAuthStatusOptions {
+    authStorage?: AuthStorage;
+    mcpOAuthStore?: McpOAuthStore;
+    discovery?: McpAuthDiscoveryMode;
+}
+export declare function resolveMcpAuthStatus(serverName: string, config: McpServerConfig, options?: ResolveMcpAuthStatusOptions): Promise<McpAuthStatus>;
+export declare function getMcpAuthStatus(serverName: string, config: McpServerConfig, authStorage?: AuthStorage, mcpOAuthStore?: McpOAuthStore): Promise<McpAuthStatus>;
 //# sourceMappingURL=auth-status.d.ts.map

package/dist/app/mcp/auth-status.js

@@ -1,33 +1,44 @@
 import { getSecret } from '../connectors/secret-store.js';
 import { getHostedMcpOAuthProviderId } from './hosted-oauth-id.js';
+import { resolveHostedMcpOAuthTimeoutMs, supportsHostedMcpOAuth } from './oauth-discovery.js';
 import { isHostedServerConfig, isStdioServerConfig } from './types.js';
 function hasConfiguredHeaders(headers) {
     return !!headers && Object.keys(headers).length > 0;
 }
-export async function getMcpAuthStatus(serverName, config, authStorage) {
+export async function resolveMcpAuthStatus(serverName, config, options = {}) {
     if (isStdioServerConfig(config)) {
         return 'unsupported';
     }
     const staticHeaders = { ...(config.headers ?? {}) };
     const secretHeaders = config.connection ? getSecret(config.connection) : undefined;
-    if (isHostedServerConfig(config) && config.oauth) {
-        if (!authStorage) {
-            return hasConfiguredHeaders(staticHeaders) || hasConfiguredHeaders(secretHeaders)
-                ? 'configured'
-                : 'not_logged_in';
-        }
-        const credential = authStorage.get(getHostedMcpOAuthProviderId(serverName, config));
-        if (credential?.type === 'oauth') {
+    if (hasConfiguredHeaders(staticHeaders) || hasConfiguredHeaders(secretHeaders)) {
+        return 'configured';
+    }
+    if (isHostedServerConfig(config)) {
+        const discovery = options.discovery ?? 'cached';
+        const providerId = getHostedMcpOAuthProviderId(serverName, config);
+        if (options.authStorage?.get(providerId)?.type === 'oauth') {
             return 'oauth';
         }
-        return hasConfiguredHeaders(staticHeaders) || hasConfiguredHeaders(secretHeaders)
-            ? 'configured'
-            : 'not_logged_in';
-    }
-    if (Object.keys(staticHeaders).length > 0 ||
-        (secretHeaders && Object.keys(secretHeaders).length > 0)) {
-        return 'configured';
+        if (config.oauth ||
+            (discovery !== 'never' && options.mcpOAuthStore?.getDiscoveryState(providerId))) {
+            return 'not_logged_in';
+        }
+        if (discovery === 'network' &&
+            (await supportsHostedMcpOAuth(serverName, config, options.mcpOAuthStore, {
+                timeoutMs: resolveHostedMcpOAuthTimeoutMs(config)
+            }).catch(() => false))) {
+            return 'not_logged_in';
+        }
+        return 'unsupported';
     }
     return 'unsupported';
 }
+export async function getMcpAuthStatus(serverName, config, authStorage, mcpOAuthStore) {
+    return resolveMcpAuthStatus(serverName, config, {
+        authStorage,
+        mcpOAuthStore,
+        discovery: 'cached'
+    });
+}
 //# sourceMappingURL=auth-status.js.map

package/dist/app/mcp/catalog.d.ts

@@ -7,7 +7,7 @@
  *
  * Use mcp_describe(server) to get full tool details.
  */
-import type { McpAuthStatus, McpConnection, McpServerStatus } from './types.js';
+import type { McpAuthStatus, McpConnection, McpFailureKind, McpServerStatus } from './types.js';
 /**
  * Build a compact tool catalog — just server names and tool names.
  * Detailed descriptions are available via mcp_describe.
@@ -21,6 +21,7 @@ export declare function buildStatusLine(entries: Array<{
     name: string;
     connected?: McpConnection;
     failure?: string;
+    failureKind?: McpFailureKind;
     authStatus: McpAuthStatus;
     transport: McpServerStatus['transport'];
 }>): string;

package/dist/app/mcp/catalog.js

@@ -7,6 +7,7 @@
  *
  * Use mcp_describe(server) to get full tool details.
  */
+import { getAgentLogPath } from '../../shared/logging/agent-log.js';
 /**
  * Build a compact tool catalog — just server names and tool names.
  * Detailed descriptions are available via mcp_describe.
@@ -41,7 +42,7 @@ function formatAuthSuffix(authStatus) {
         case 'oauth':
             return 'oauth';
         case 'not_logged_in':
-            return 'login required';
+            return 'needs login';
         case 'unsupported':
         default:
             return 'no auth';
@@ -49,6 +50,7 @@ function formatAuthSuffix(authStatus) {
 }
 export function buildStatusLine(entries) {
     const parts = [];
+    let hasFailure = false;
     for (const entry of entries) {
         const authSuffix = entry.transport === 'streamable_http' && entry.authStatus !== 'unsupported'
             ? `, ${formatAuthSuffix(entry.authStatus)}`
@@ -57,12 +59,22 @@ export function buildStatusLine(entries) {
             parts.push(`${entry.name} (${entry.connected.tools.length} tools${authSuffix})`);
         }
         else if (entry.failure) {
-            parts.push(`${entry.name} (failed${authSuffix})`);
+            hasFailure = true;
+            if (entry.failureKind === 'auth_required') {
+                parts.push(`${entry.name} (needs login - run /login -> MCP: ${entry.name})`);
+            }
+            else {
+                parts.push(`${entry.name} (failed)`);
+            }
         }
         else {
             parts.push(`${entry.name} (${formatAuthSuffix(entry.authStatus)})`);
         }
     }
-    return parts.length > 0 ? `[MCP] ${parts.join(', ')}` : '';
+    if (parts.length === 0) {
+        return '';
+    }
+    const logSuffix = hasFailure ? `; logs: ${getAgentLogPath()}` : '';
+    return `[MCP] ${parts.join(', ')}${logSuffix}`;
 }
 //# sourceMappingURL=catalog.js.map

package/dist/app/mcp/config.d.ts

@@ -1,20 +1,25 @@
 /**
- * Load and merge MCP server configs from global + project paths.
+ * Load MCP server config from the global agent directory.
  *
- * Global:  ~/.shortcut/agent/mcp.json
- * Project: .shortcut/mcp.json (in cwd)
- *
- * Project servers override global servers with the same name.
+ * MCPs are user-level integrations for ShortcutXL spreadsheet sessions, not
+ * project-local coding config.
  */
-import { type McpServerConfig } from './types.js';
+import { type McpConfig, type McpServerConfig } from './types.js';
+export declare function getMcpConfigPath(globalConfigDir: string): string;
+export declare function readMcpConfigFile(path: string): McpConfig;
+export declare function writeMcpConfigFile(path: string, config: McpConfig): void;
+export declare function upsertMcpServerConfig(path: string, name: string, config: McpServerConfig, options?: {
+    force?: boolean;
+}): void;
+export declare function removeMcpServerConfig(path: string, name: string): boolean;
+export declare function validateServerConfig(name: string, cfg: unknown): cfg is McpServerConfig;
+export declare function normalizeServerConfig(name: string, cfg: McpServerConfig): McpServerConfig;
 interface LoadConfigOptions {
     cwd: string;
     globalConfigDir: string;
 }
 /**
- * Load and merge MCP server configs from global and project paths.
- * Project-local servers override global servers with the same name.
- * Warns on secrets found in project-local config.
+ * Load MCP server configs from the global agent path only.
  */
 export declare function loadMcpConfig(options: LoadConfigOptions): Record<string, McpServerConfig>;
 export {};