shortcutxl 0.3.76 → 0.3.78

package/dist/app/agent-session.js

@@ -98,14 +98,8 @@ export class AgentSession {
     /** Details from the last prePromptContext call (e.g. { workbooks: string[] }). Read by TUI for annotations. */
     lastPrePromptDetails;
     _sessionState = new SessionState();
-    // Collaboration client (lazily created on first /collab use)
-    _collabClient = null;
     // Sheet engine pool (set from main.ts when new-sheet mode is active)
     _sheetPool = null;
-    // Collaboration awareness (created after joining a room with an active workbook)
-    _collabAwareness = null;
-    // CRDT sync orchestrator (created after joining a room)
-    _collabSync = null;
     // Model registry for API key resolution
     _modelRegistry;
     /** Fire-and-forget tool-call summary generation. */
@@ -614,13 +608,6 @@ export class AgentSession {
         this._disconnectFromAgent();
         this._summaryEmitter.abort();
         this._eventListeners = [];
-        // Clean up collaboration resources
-        this._collabSync?.destroy();
-        this._collabSync = null;
-        this._collabAwareness?.destroy();
-        this._collabAwareness = null;
-        this._collabClient?.destroy();
-        this._collabClient = null;
     }
     /**
      * Wait for any in-flight suggestion generation to complete.
@@ -1239,14 +1226,6 @@ export class AgentSession {
     get resourceLoader() {
         return this._resourceLoader;
     }
-    /** Active collaboration client when the session is part of a collab room, otherwise null. */
-    get collabClient() {
-        return this._collabClient;
-    }
-    /** Attach or detach the collaboration client for this session. */
-    set collabClient(client) {
-        this._collabClient = client;
-    }
     /** Sheet-engine pool currently bound to this session, or null if unbound. */
     get sheetPool() {
         return this._sheetPool;
@@ -1255,22 +1234,6 @@ export class AgentSession {
     set sheetPool(pool) {
         this._sheetPool = pool;
     }
-    /** Awareness layer for the active collab session (peer cursors, presence), or null. */
-    get collabAwareness() {
-        return this._collabAwareness;
-    }
-    /** Attach or detach the collab awareness layer. */
-    set collabAwareness(awareness) {
-        this._collabAwareness = awareness;
-    }
-    /** Collab document sync controller for this session, or null if not in a room. */
-    get collabSync() {
-        return this._collabSync;
-    }
-    /** Attach or detach the collab document sync controller. */
-    set collabSync(sync) {
-        this._collabSync = sync;
-    }
     /**
      * Abort current operation and wait for agent to become idle.
      */

package/dist/app/approvals/approval-errors.d.ts

@@ -0,0 +1,15 @@
+import type { AgentToolResult } from '../../core/core-types.js';
+export declare const APPROVAL_ERROR_CODE: {
+    readonly INTERACTIVE_APPROVAL_UNAVAILABLE: "interactive_approval_unavailable";
+    readonly USER_REJECTED: "approval_rejected";
+};
+export type ApprovalErrorCode = (typeof APPROVAL_ERROR_CODE)[keyof typeof APPROVAL_ERROR_CODE];
+export interface ApprovalErrorDetails {
+    code: ApprovalErrorCode;
+    approvalKind: string;
+    toolName: string;
+}
+export declare const INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE = "Tool execution requires approval, but this runtime does not support interactive approvals.";
+export declare const USER_REJECTED_APPROVAL_MESSAGE = "Tool execution rejected by user.";
+export declare function createApprovalErrorResult(code: ApprovalErrorCode, message: string, approvalKind: string, toolName: string): AgentToolResult<ApprovalErrorDetails>;
+//# sourceMappingURL=approval-errors.d.ts.map

package/dist/app/approvals/approval-errors.js

@@ -0,0 +1,14 @@
+export const APPROVAL_ERROR_CODE = {
+    INTERACTIVE_APPROVAL_UNAVAILABLE: 'interactive_approval_unavailable',
+    USER_REJECTED: 'approval_rejected'
+};
+export const INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE = 'Tool execution requires approval, but this runtime does not support interactive approvals.';
+export const USER_REJECTED_APPROVAL_MESSAGE = 'Tool execution rejected by user.';
+export function createApprovalErrorResult(code, message, approvalKind, toolName) {
+    return {
+        content: [{ type: 'text', text: message }],
+        details: { code, approvalKind, toolName },
+        isError: true
+    };
+}
+//# sourceMappingURL=approval-errors.js.map

package/dist/app/approvals/runtime-approval-gates.d.ts

@@ -1,11 +1,10 @@
 import type { ExcelApprovalPayload } from '../local/tools/execute-code/approval-payload.js';
-import type { ApprovalGate, BashApprovalData, FileAccessApprovalData, SwitchModeApprovalData, TaskSpawnApprovalData } from './types.js';
+import type { ApprovalGate, BashApprovalData, FileAccessApprovalData, SwitchModeApprovalData } from './types.js';
 /** Approval gates required by the local Shortcut runtime composition root. */
 export interface RuntimeApprovalGates {
     readonly bash: ApprovalGate<BashApprovalData>;
     readonly excel: ApprovalGate<ExcelApprovalPayload>;
     readonly fileAccess: ApprovalGate<FileAccessApprovalData>;
     readonly switchMode: ApprovalGate<SwitchModeApprovalData>;
-    readonly taskSpawn: ApprovalGate<TaskSpawnApprovalData>;
 }
 //# sourceMappingURL=runtime-approval-gates.d.ts.map

package/dist/app/approvals/tool-approval.d.ts

@@ -10,6 +10,7 @@ import { type ApprovalChoice, type ApprovalGate, type ApprovalRequest } from './
 export declare function withPreApproval<T extends TSchema, D>(tool: ToolDefinition<T>, approval: ApprovalGate<D>, buildRequest: (params: Record<string, unknown>, ctx: ToolExecutionContext | undefined) => ApprovalRequest<D> | Promise<ApprovalRequest<D>>, options?: {
     alwaysPrompt?: boolean;
     isContentSafe?: (params: Record<string, unknown>, ctx: ToolExecutionContext | undefined) => boolean | Promise<boolean>;
+    isHeadlessApprovalAllowed?: (ctx: ToolExecutionContext | undefined) => boolean;
     onRequested?: (request: ApprovalRequest<D>) => void;
     onAccepted?: (request: ApprovalRequest<D>, choice: ApprovalChoice) => void;
     onRejected?: (request: ApprovalRequest<D>) => void;

package/dist/app/approvals/tool-approval.js

@@ -4,6 +4,7 @@
  * Wraps a ToolDefinition with a user-approval prompt before executing.
  */
 import { getApprovalSurface, resolveApprovalExecutionDecision } from '../permissions/approval-surface.js';
+import { APPROVAL_ERROR_CODE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, USER_REJECTED_APPROVAL_MESSAGE, createApprovalErrorResult } from './approval-errors.js';
 import { APPROVAL } from './types.js';
 /** Map an ApprovalChoice to a default summary message prepended to the tool result. */
 function defaultApprovalSummary(choice) {
@@ -12,10 +13,6 @@ function defaultApprovalSummary(choice) {
             return 'User approved this.';
         case APPROVAL.ACCEPT_ALL:
             return 'User enabled session auto-approve.';
-        case APPROVAL.RUN_FOREGROUND:
-            return 'User approved running this task in the foreground.';
-        case APPROVAL.RUN_BACKGROUND:
-            return 'User approved running this task in the background.';
         case APPROVAL.ALLOW_ONCE:
             return 'User allowed this once.';
         case APPROVAL.ALLOW_FILE:
@@ -35,7 +32,7 @@ function prependApprovalSummary(result, summary) {
 }
 /** Wrap a tool with a pre-execution approval gate that prompts when policy requires it. */
 export function withPreApproval(tool, approval, buildRequest, options = {}) {
-    const { alwaysPrompt, isContentSafe, onRequested, onAccepted, onRejected, isApprovedChoiceAllowed, describeApprovedChoice, applyApprovalContext } = options;
+    const { alwaysPrompt, isContentSafe, isHeadlessApprovalAllowed, onRequested, onAccepted, onRejected, isApprovedChoiceAllowed, describeApprovedChoice, applyApprovalContext } = options;
     return {
         name: tool.name,
         label: tool.label,
@@ -44,48 +41,39 @@ export function withPreApproval(tool, approval, buildRequest, options = {}) {
         isReadOnly: tool.isReadOnly,
         promptGuidelines: tool.promptGuidelines,
         async execute(toolCallId, params, signal, onUpdate, ctx) {
+            const extCtx = ctx;
             const safe = alwaysPrompt
                 ? false
                 : ((await isContentSafe?.(params, ctx)) ?? false);
-            const extCtx = ctx;
             const request = await buildRequest(params, ctx);
             const decision = resolveApprovalExecutionDecision({
                 surface: getApprovalSurface(extCtx),
                 isSafe: safe,
                 isAutoApproved: approval.isAutoApproved(),
                 alwaysRequireExplicitApproval: request.alwaysRequireExplicitApproval === true,
-                allowHeadlessApproval: ctx?.permissionPolicy?.approvals.allowHeadlessApproval ?? false
+                allowHeadlessApproval: isHeadlessApprovalAllowed?.(ctx) ??
+                    ctx?.permissionPolicy?.approvals.allowHeadlessApproval ??
+                    false
             });
             if (decision === 'deny') {
-                return {
-                    content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                    details: undefined
-                };
+                onRejected?.(request);
+                return createApprovalErrorResult(APPROVAL_ERROR_CODE.INTERACTIVE_APPROVAL_UNAVAILABLE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, request.kind, tool.name);
             }
             if (decision === 'prompt') {
                 if (!extCtx) {
                     onRejected?.(request);
-                    return {
-                        content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                        details: undefined
-                    };
+                    return createApprovalErrorResult(APPROVAL_ERROR_CODE.INTERACTIVE_APPROVAL_UNAVAILABLE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, request.kind, tool.name);
                 }
                 onRequested?.(request);
                 const choice = await approval.requestApproval(request, extCtx);
                 if (choice === APPROVAL.REJECT || choice === undefined) {
                     onRejected?.(request);
-                    return {
-                        content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                        details: undefined
-                    };
+                    return createApprovalErrorResult(APPROVAL_ERROR_CODE.USER_REJECTED, USER_REJECTED_APPROVAL_MESSAGE, request.kind, tool.name);
                 }
                 const allowedChoice = (await isApprovedChoiceAllowed?.(request, choice)) ?? true;
                 if (!allowedChoice) {
                     onRejected?.(request);
-                    return {
-                        content: [{ type: 'text', text: 'Tool execution rejected by user.' }],
-                        details: undefined
-                    };
+                    return createApprovalErrorResult(APPROVAL_ERROR_CODE.USER_REJECTED, USER_REJECTED_APPROVAL_MESSAGE, request.kind, tool.name);
                 }
                 onAccepted?.(request, choice);
                 if (choice === APPROVAL.ACCEPT_ALL) {

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

@@ -9,8 +9,6 @@ import type { ExtensionContext } from '../extensions/index.js';
 export declare const APPROVAL: {
     readonly ACCEPT: "Accept";
     readonly ACCEPT_ALL: "Accept All";
-    readonly RUN_FOREGROUND: "Run foreground";
-    readonly RUN_BACKGROUND: "Run background";
     readonly ALLOW_ONCE: "Allow Once";
     readonly ALLOW_FILE: "Always Allow File";
     readonly ALLOW_FOLDER: "Always Allow Folder";
@@ -61,18 +59,6 @@ export interface BashApprovalData {
         reason: string;
     }>;
 }
-export interface TaskSpawnApprovalData {
-    subagentType: string;
-    name: string;
-    query: string;
-    model?: string;
-    /** Task spawn approval is all-or-nothing: approved children run as full workers. */
-    fullWorker: true;
-    /** True when this subagent can recursively spawn more full-worker children. */
-    canSpawnSubagents: boolean;
-    /** Launch mode requested by the tool call before user approval overrides. */
-    requestedRunInBackground: boolean;
-}
 export interface SwitchModeApprovalData {
     currentMode: string;
     targetMode: string;

package/dist/app/approvals/types.js

@@ -8,8 +8,6 @@
 export const APPROVAL = {
     ACCEPT: 'Accept',
     ACCEPT_ALL: 'Accept All',
-    RUN_FOREGROUND: 'Run foreground',
-    RUN_BACKGROUND: 'Run background',
     ALLOW_ONCE: 'Allow Once',
     ALLOW_FILE: 'Always Allow File',
     ALLOW_FOLDER: 'Always Allow Folder',

package/dist/app/background/tool-summaries.js

@@ -35,8 +35,6 @@ export async function generateToolSummaryDetailed(input, shortcutLlmProxy, optio
                 { role: 'human', content: userContent }
             ],
             max_output_tokens: maxOutputTokens,
-            effort_level: 'low',
-            thinking_type: 'off',
             llmOperation: 'summarize'
         }, {
             signal

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

@@ -42,9 +42,7 @@ const ALL_BUILTIN_SLASH_COMMANDS = [
     { name: 'port-skills', description: 'Discover and register external skill roots' },
     { name: 'download-skills', description: 'Download skills from cloud' },
     { name: 'upload-skills', description: 'Upload local skills to cloud' },
-    { name: 'reload', description: 'Reload extensions, skills, prompts, and themes' },
-    // Collaboration
-    { name: 'collab', description: 'Create or join a collaboration room' }
+    { name: 'reload', description: 'Reload extensions, skills, prompts, and themes' }
 ];
 /** All builtin command names, used to prevent extension collisions. */
 export const ALL_BUILTIN_SLASH_COMMAND_NAMES = new Set(ALL_BUILTIN_SLASH_COMMANDS.map((cmd) => cmd.name));

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

@@ -23,7 +23,7 @@ export interface ComExecResult {
     cfTxId?: string;
     editMode?: boolean;
 }
-export type ApprovalOutcome = 'accepted' | 'failed' | 'reverted' | 'revert-failed' | 'rejected';
+export type ApprovalOutcome = 'accepted' | 'approval-unavailable' | 'failed' | 'reverted' | 'revert-failed' | 'rejected';
 export interface LocalExecResult {
     result: ComExecResult;
     outcome: ApprovalOutcome;

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

@@ -10,6 +10,7 @@
  * - `createExcelExecTool()` (COM ToolDefinition wrapper)
  */
 import { log } from '../../../../shared/logging/agent-log.js';
+import { INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE } from '../../../approvals/approval-errors.js';
 import { APPROVAL } from '../../../approvals/types.js';
 import { getApprovalSurface, resolveApprovalExecutionDecision } from '../../../permissions/approval-surface.js';
 import { getEffectiveExcelHttpUrl } from '../../../xll/endpoint.js';
@@ -60,7 +61,7 @@ function isDangerousExcelLifecycleBypassed(ctx) {
 }
 async function requestAlwaysConfirmApproval(approval, ctx, description, dangerousOperations, observability) {
     if (isDangerousExcelLifecycleBypassed(ctx)) {
-        return APPROVAL.ACCEPT;
+        return { choice: APPROVAL.ACCEPT, unavailable: false };
     }
     const request = {
         kind: 'execute_code',
@@ -85,16 +86,16 @@ async function requestAlwaysConfirmApproval(approval, ctx, description, dangerou
     });
     if (decision !== 'prompt' || !approval || !ctx) {
         observability?.onRejected?.(request);
-        return APPROVAL.REJECT;
+        return { choice: APPROVAL.REJECT, unavailable: decision === 'deny' };
     }
     observability?.onRequested?.(request);
     const choice = await approval.requestApproval(request, ctx);
     if (choice === APPROVAL.REJECT || choice === undefined) {
         observability?.onRejected?.(request);
-        return choice;
+        return { choice, unavailable: false };
     }
     observability?.onAccepted?.(request, choice);
-    return choice;
+    return { choice, unavailable: false };
 }
 // ---------------------------------------------------------------------------
 // Approval resolution
@@ -146,7 +147,7 @@ export async function resolveApproval(result, approval, postControl, ctx, descri
                 try {
                     await postControl({ control: CONTROL.REVERT, cfTxId });
                     observability?.onReverted?.(request);
-                    return { outcome: 'reverted' };
+                    return { outcome: 'rejected' };
                 }
                 catch {
                     if (cfTxId != null) {
@@ -239,11 +240,17 @@ export async function executeComLocally(excelHttpUrl, code, options) {
     const analysis = analyzeComWriteCode(code);
     const dangerousLifecycleBypassed = analysis.alwaysRequireApproval && isDangerousExcelLifecycleBypassed(ctx);
     if (analysis.alwaysRequireApproval) {
-        const choice = await requestAlwaysConfirmApproval(approval, ctx, description, analysis.dangerousOperations, observability);
+        const approvalResult = await requestAlwaysConfirmApproval(approval, ctx, description, analysis.dangerousOperations, observability);
+        const { choice } = approvalResult;
         if (choice !== APPROVAL.ACCEPT && choice !== APPROVAL.ACCEPT_ALL) {
             return {
-                result: { ok: true, output: 'Excel operation rejected by user.' },
-                outcome: 'rejected'
+                result: {
+                    ok: true,
+                    output: approvalResult.unavailable
+                        ? INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE
+                        : 'Excel operation rejected by user.'
+                },
+                outcome: approvalResult.unavailable ? 'approval-unavailable' : 'rejected'
             };
         }
         if (choice === APPROVAL.ACCEPT_ALL) {
@@ -264,8 +271,11 @@ export async function executeComLocally(excelHttpUrl, code, options) {
         });
     if (executionDecision === 'deny') {
         return {
-            result: { ok: true, output: 'Excel operation rejected by user.' },
-            outcome: 'rejected'
+            result: {
+                ok: true,
+                output: INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE
+            },
+            outcome: 'approval-unavailable'
         };
     }
     let result = await sendExecRequest();

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

@@ -8,6 +8,7 @@
 import { Type } from '@sinclair/typebox';
 import { EXECUTE_CODE } from '../../../../tool-names.js';
 import { truncateOutput } from '../../../../utils/truncate.js';
+import { APPROVAL_ERROR_CODE, INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE, USER_REJECTED_APPROVAL_MESSAGE } from '../../../approvals/approval-errors.js';
 import { buildLocalExcelHttpUrl, parseExcelHttpPort } from '../../../xll/http-url.js';
 import { executeComLocally } from './executor.js';
 const TOOL_NAME = EXECUTE_CODE;
@@ -90,8 +91,26 @@ export function createExcelExecTool(httpPort, approval, observability) {
             }
             if (outcome === 'rejected') {
                 return {
-                    content: [{ type: 'text', text: 'Excel operation rejected by user.' }],
-                    details: result
+                    content: [{ type: 'text', text: USER_REJECTED_APPROVAL_MESSAGE }],
+                    details: {
+                        ...result,
+                        code: APPROVAL_ERROR_CODE.USER_REJECTED,
+                        approvalKind: EXECUTE_CODE,
+                        toolName: EXECUTE_CODE
+                    },
+                    isError: true
+                };
+            }
+            if (outcome === 'approval-unavailable') {
+                return {
+                    content: [{ type: 'text', text: INTERACTIVE_APPROVAL_UNAVAILABLE_MESSAGE }],
+                    details: {
+                        ...result,
+                        code: APPROVAL_ERROR_CODE.INTERACTIVE_APPROVAL_UNAVAILABLE,
+                        approvalKind: EXECUTE_CODE,
+                        toolName: EXECUTE_CODE
+                    },
+                    isError: true
                 };
             }
             if (outcome === 'failed' || !result.ok) {

package/dist/app/modes/action/agent.js

@@ -4,10 +4,9 @@
  * Provides the spreadsheet execution tool set for making changes to the workbook.
  * Can switch to plan or installation mode.
  */
-import { MODE } from '../../../mode-names.js';
 import { ACTION_SWITCH_MODE, BASH, EXECUTE_CODE, EXECUTE_TOOL, GET_TOOL_INFO, MCP_TOOL_NAMES, REFRESH_CONTEXT, SEND_MESSAGE, TAKE_SCREENSHOT, TASK, WRITE } from '../../../tool-names.js';
+import { ACTION_MODE_METADATA } from '../metadata.js';
 import { buildActionPrompt } from './prompt.js';
-const DESCRIPTION = 'Execute changes to the spreadsheet.';
 export const ACTION_AGENT_TOOL_NAMES = [
     BASH,
     WRITE,
@@ -24,11 +23,11 @@ export const ACTION_AGENT_TOOL_NAMES = [
 /** Construct the action-mode agent definition with the full execution toolset. */
 export function actionAgent() {
     return {
-        name: MODE.ACTION,
-        description: DESCRIPTION,
+        name: ACTION_MODE_METADATA.name,
+        description: ACTION_MODE_METADATA.description,
         systemPrompt: buildActionPrompt(),
         tools: ACTION_AGENT_TOOL_NAMES,
-        switchTo: [MODE.PLAN, MODE.INSTALLATION]
+        switchTo: ACTION_MODE_METADATA.switchTo
     };
 }
 //# sourceMappingURL=agent.js.map

package/dist/app/modes/ask/agent.js

@@ -4,12 +4,10 @@
  * Reviews, audits, and explains spreadsheet content without modification.
  * This is a sink state: the agent cannot switch out of ask mode.
  */
-import { MODE } from '../../../mode-names.js';
-import { BASH, EXECUTE_CODE, EXECUTE_TOOL, FIND, GET_TOOL_INFO, GREP, LLM_ANALYSIS, LS, MCP_TOOL_NAMES, READ, TAKE_SCREENSHOT } from '../../../tool-names.js';
+import { EXECUTE_CODE, EXECUTE_TOOL, FIND, GET_TOOL_INFO, GREP, LLM_ANALYSIS, LS, MCP_TOOL_NAMES, READ, TAKE_SCREENSHOT } from '../../../tool-names.js';
+import { ASK_MODE_METADATA } from '../metadata.js';
 import { buildAskPrompt } from './prompt.js';
-const DESCRIPTION = 'Read-only analysis mode — reviews, audits, and explains spreadsheet content. Switch to ask mode for user queries that center on audit, review, and understanding without any spreadsheet modifications.';
 const TOOLS = [
-    BASH,
     EXECUTE_CODE,
     READ,
     GREP,
@@ -23,8 +21,8 @@ const TOOLS = [
 ];
 export function askAgent() {
     return {
-        name: MODE.ASK,
-        description: DESCRIPTION,
+        name: ASK_MODE_METADATA.name,
+        description: ASK_MODE_METADATA.description,
         systemPrompt: buildAskPrompt(),
         tools: TOOLS
     };

package/dist/app/modes/index.js

@@ -9,29 +9,39 @@ export { askAgent } from './ask/agent.js';
 export { installationAgent } from './installation/agent.js';
 export { manageAgent } from './manage/agent.js';
 export { planAgent } from './plan/agent.js';
+import { MODE } from '../../mode-names.js';
 import { actionAgent } from './action/agent.js';
 import { askAgent } from './ask/agent.js';
 import { installationAgent } from './installation/agent.js';
 import { manageAgent } from './manage/agent.js';
+import { MODE_METADATA } from './metadata.js';
 import { planAgent } from './plan/agent.js';
-function buildModes() {
-    return [installationAgent(), actionAgent(), planAgent(), askAgent(), manageAgent()];
-}
+const MODE_FACTORIES = new Map([
+    [MODE.INSTALLATION, installationAgent],
+    [MODE.ACTION, actionAgent],
+    [MODE.PLAN, planAgent],
+    [MODE.ASK, askAgent],
+    [MODE.MANAGE, manageAgent]
+]);
 export function getModes() {
-    return buildModes();
+    return MODE_METADATA.map((metadata) => {
+        const factory = MODE_FACTORIES.get(metadata.name);
+        if (!factory) {
+            throw new Error(`No mode factory registered for "${metadata.name}".`);
+        }
+        return factory();
+    });
 }
 export function getMode(name) {
-    return buildModes().find((mode) => mode.name === name);
+    return MODE_FACTORIES.get(name)?.();
 }
 export function getModeNames() {
-    return buildModes().map((mode) => mode.name);
+    return MODE_METADATA.map((mode) => mode.name);
 }
 export function buildModeList() {
-    return buildModes()
-        .map((mode) => {
+    return MODE_METADATA.map((mode) => {
         const targets = mode.switchTo?.join(', ') ?? 'none';
         return `- **${mode.name}**: ${mode.description} (can switch to: ${targets})`;
-    })
-        .join('\n');
+    }).join('\n');
 }
 //# sourceMappingURL=index.js.map

package/dist/app/modes/installation/agent.js

@@ -6,8 +6,8 @@
  * Accepts optional preflight log entries to communicate what the deterministic
  * preflight script already accomplished before the agent took over.
  */
-import { MODE } from '../../../mode-names.js';
 import { BASH, EDIT, EXECUTE_CODE, GREP, INSTALLATION_SWITCH_MODE, READ, WRITE } from '../../../tool-names.js';
+import { INSTALLATION_MODE_METADATA } from '../metadata.js';
 import { buildMacInstallationPrompt } from './prompt-mac.js';
 import { buildWindowsInstallationPrompt } from './prompt-windows.js';
 function buildInstallationPrompt(preflightLog) {
@@ -16,15 +16,14 @@ function buildInstallationPrompt(preflightLog) {
     }
     return buildWindowsInstallationPrompt(preflightLog);
 }
-const DESCRIPTION = 'First-time setup for ShortcutXL.';
 const TOOLS = [READ, BASH, EDIT, WRITE, GREP, EXECUTE_CODE, INSTALLATION_SWITCH_MODE];
 export function installationAgent(preflightLog) {
     return {
-        name: MODE.INSTALLATION,
-        description: DESCRIPTION,
+        name: INSTALLATION_MODE_METADATA.name,
+        description: INSTALLATION_MODE_METADATA.description,
         systemPrompt: buildInstallationPrompt(preflightLog),
         tools: TOOLS,
-        switchTo: [MODE.ACTION]
+        switchTo: INSTALLATION_MODE_METADATA.switchTo
     };
 }
 //# sourceMappingURL=agent.js.map

package/dist/app/modes/manage/agent.js

@@ -4,16 +4,15 @@
  * Delegates workbook work to subagents, with bash for coordination files and inspection.
  * Explicit /manage can enter it, but it does not switch out again.
  */
-import { MODE } from '../../../mode-names.js';
 import { BASH, EXECUTE_TOOL, GET_TOOL_INFO, MCP_TOOL_NAMES, SEND_MESSAGE, TASK } from '../../../tool-names.js';
+import { MANAGE_MODE_METADATA } from '../metadata.js';
 import { buildManagePrompt } from './prompt.js';
-const DESCRIPTION = 'Orchestration mode — decomposes complex tasks, delegates to subagents in parallel, and synthesizes results.';
 const TOOLS = [TASK, SEND_MESSAGE, GET_TOOL_INFO, EXECUTE_TOOL, BASH, ...MCP_TOOL_NAMES];
 /** Construct the manage-mode agent definition that orchestrates work via subagents. */
 export function manageAgent() {
     return {
-        name: MODE.MANAGE,
-        description: DESCRIPTION,
+        name: MANAGE_MODE_METADATA.name,
+        description: MANAGE_MODE_METADATA.description,
         systemPrompt: buildManagePrompt(),
         tools: TOOLS
     };

package/dist/app/modes/manage/prompt.js

@@ -4,7 +4,6 @@
  * Pure orchestration mode: decomposes tasks, delegates to subagents,
  * and synthesizes results. No direct file/spreadsheet access.
  */
-import { buildCurrentSkillsSection } from '../../prompts/shared-guidelines.js';
 const MANAGE_BASE = `\
 You are Shortcut in Manage Mode — an orchestrator. You decompose tasks, delegate workbook/document work to subagents via the task tool, use bash for coordination files and lightweight inspection, and synthesize results.
 
@@ -79,6 +78,6 @@ Every task query to a subagent must include:
 
 `;
 export function buildManagePrompt() {
-    return [MANAGE_BASE, buildCurrentSkillsSection()].join('\n\n');
+    return MANAGE_BASE;
 }
 //# sourceMappingURL=prompt.js.map

package/dist/app/modes/metadata.d.ts

@@ -0,0 +1,31 @@
+export interface ModeMetadata {
+    readonly name: string;
+    readonly description: string;
+    readonly switchTo?: readonly string[];
+}
+export declare const INSTALLATION_MODE_METADATA: {
+    readonly name: "installation";
+    readonly description: "First-time setup for ShortcutXL.";
+    readonly switchTo: readonly ["action"];
+};
+export declare const ACTION_MODE_METADATA: {
+    readonly name: "action";
+    readonly description: "Execute changes to the spreadsheet.";
+    readonly switchTo: readonly ["plan", "installation"];
+};
+export declare const PLAN_MODE_METADATA: {
+    readonly name: "plan";
+    readonly description: "Read-only planning mode for exploration, clarifying requirements and drafting an implementation plan.";
+    readonly switchTo: readonly ["action"];
+};
+export declare const ASK_MODE_METADATA: {
+    readonly name: "ask";
+    readonly description: "Read-only analysis mode — reviews, audits, and explains spreadsheet content. Switch to ask mode for user queries that center on audit, review, and understanding without any spreadsheet modifications.";
+};
+export declare const MANAGE_MODE_METADATA: {
+    readonly name: "manage";
+    readonly description: "Orchestration mode — decomposes complex tasks, delegates to subagents in parallel, and synthesizes results.";
+};
+export declare const MODE_METADATA: readonly ModeMetadata[];
+export declare function getModeMetadata(name: string): ModeMetadata | undefined;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/app/modes/metadata.js

@@ -0,0 +1,35 @@
+import { MODE } from '../../mode-names.js';
+export const INSTALLATION_MODE_METADATA = {
+    name: MODE.INSTALLATION,
+    description: 'First-time setup for ShortcutXL.',
+    switchTo: [MODE.ACTION]
+};
+export const ACTION_MODE_METADATA = {
+    name: MODE.ACTION,
+    description: 'Execute changes to the spreadsheet.',
+    switchTo: [MODE.PLAN, MODE.INSTALLATION]
+};
+export const PLAN_MODE_METADATA = {
+    name: MODE.PLAN,
+    description: 'Read-only planning mode for exploration, clarifying requirements and drafting an implementation plan.',
+    switchTo: [MODE.ACTION]
+};
+export const ASK_MODE_METADATA = {
+    name: MODE.ASK,
+    description: 'Read-only analysis mode — reviews, audits, and explains spreadsheet content. Switch to ask mode for user queries that center on audit, review, and understanding without any spreadsheet modifications.'
+};
+export const MANAGE_MODE_METADATA = {
+    name: MODE.MANAGE,
+    description: 'Orchestration mode — decomposes complex tasks, delegates to subagents in parallel, and synthesizes results.'
+};
+export const MODE_METADATA = [
+    INSTALLATION_MODE_METADATA,
+    ACTION_MODE_METADATA,
+    PLAN_MODE_METADATA,
+    ASK_MODE_METADATA,
+    MANAGE_MODE_METADATA
+];
+export function getModeMetadata(name) {
+    return MODE_METADATA.find((mode) => mode.name === name);
+}
+//# sourceMappingURL=metadata.js.map