shortcutxl 0.2.19 → 0.2.21

package/dist/custom/new-sheet/sheet-engine.js

@@ -0,0 +1,146 @@
+/**
+ * Sheet Engine Pool — manages multiple headless workbooks via @shortcut/sdk.
+ *
+ * Each workbook is a HeadlessEngine backed by the native Rust compute-core.
+ * Uses the full kernel (ComputeBridge, DocumentContext) so formulas, undo,
+ * and CRDT sync all work correctly.
+ *
+ * Workbooks are keyed by name (basename):
+ * - loadWorkbook("/path/to/Budget.xlsx") → keyed as "Budget.xlsx"
+ * - createWorkbook() → auto-named "Book1", "Book2", etc.
+ *
+ * The pool persists for the entire agent session. Workbook state (cells,
+ * formulas, undo history) survives across sandbox executions — same model
+ * as Excel staying open in COM mode.
+ */
+import { createHeadlessEngine } from './sdk-types.js';
+import { createRequire } from 'module';
+// ---------------------------------------------------------------------------
+// SheetEnginePool
+// ---------------------------------------------------------------------------
+export class SheetEnginePool {
+    computeAddon;
+    xlsxAddon;
+    workbooks = new Map();
+    /** name → original file path (for loaded workbooks) */
+    sourcePaths = new Map();
+    nextBookNum = 1;
+    /** The most recently created/loaded workbook name. */
+    activeWorkbookName = null;
+    constructor(computeAddon, xlsxAddon) {
+        this.computeAddon = computeAddon;
+        this.xlsxAddon = xlsxAddon;
+    }
+    /** Create a pool, loading the native addons. */
+    static async init() {
+        const esmRequire = createRequire(import.meta.url);
+        const computeAddon = esmRequire('@shortcut/compute-core-napi');
+        let xlsxAddon;
+        try {
+            xlsxAddon = esmRequire('@shortcut/xlsx-parser-napi');
+        }
+        catch {
+            // XLSX import won't be available
+        }
+        return new SheetEnginePool(computeAddon, xlsxAddon);
+    }
+    // =========================================================================
+    // Lifecycle
+    // =========================================================================
+    /** Create a blank workbook. Auto-named "Book1", "Book2", etc. Returns the name. */
+    async createWorkbook(name) {
+        const wbName = name ?? `Book${this.nextBookNum++}`;
+        if (this.workbooks.has(wbName)) {
+            this.activeWorkbookName = wbName;
+            return wbName;
+        }
+        const engine = await createHeadlessEngine({ computeAddon: this.computeAddon });
+        this.workbooks.set(wbName, {
+            engine,
+            workbook: engine.workbook
+        });
+        this.activeWorkbookName = wbName;
+        return wbName;
+    }
+    /**
+     * Open a workbook from XLSX bytes, keyed by name.
+     * If a workbook with this name is already open, returns the existing one (idempotent).
+     */
+    async openWorkbook(name, xlsxBuffer) {
+        if (this.workbooks.has(name)) {
+            this.activeWorkbookName = name;
+            return name;
+        }
+        const engine = await createHeadlessEngine({
+            computeAddon: this.computeAddon,
+            xlsxSource: xlsxBuffer
+        });
+        this.workbooks.set(name, {
+            engine,
+            workbook: engine.workbook
+        });
+        this.activeWorkbookName = name;
+        return name;
+    }
+    /** Close a workbook and free resources. */
+    async close(name) {
+        const handle = this.workbooks.get(name);
+        if (!handle)
+            return;
+        await handle.engine.dispose();
+        this.workbooks.delete(name);
+        this.sourcePaths.delete(name);
+        if (this.activeWorkbookName === name) {
+            // Set active to the most recently remaining, or null
+            const remaining = [...this.workbooks.keys()];
+            this.activeWorkbookName = remaining.length > 0 ? remaining[remaining.length - 1] : null;
+        }
+    }
+    /** Close all workbooks. */
+    async closeAll() {
+        const names = [...this.workbooks.keys()];
+        await Promise.all(names.map((n) => this.close(n)));
+        this.activeWorkbookName = null;
+    }
+    get size() {
+        return this.workbooks.size;
+    }
+    /** List all open workbook names. */
+    listWorkbooks() {
+        return [...this.workbooks.keys()];
+    }
+    /** Check if a workbook is open. */
+    has(name) {
+        return this.workbooks.has(name);
+    }
+    // =========================================================================
+    // Source path tracking
+    // =========================================================================
+    /** Record the original file path for a loaded workbook. */
+    setSourcePath(name, path) {
+        this.sourcePaths.set(name, path);
+    }
+    /** Get the original file path for a loaded workbook (undefined for created workbooks). */
+    getSourcePath(name) {
+        return this.sourcePaths.get(name);
+    }
+    // =========================================================================
+    // Raw access
+    // =========================================================================
+    getWorkbook(name) {
+        return this.getHandle(name).workbook;
+    }
+    getEngine(name) {
+        return this.getHandle(name).engine;
+    }
+    // =========================================================================
+    // Internals
+    // =========================================================================
+    getHandle(name) {
+        const handle = this.workbooks.get(name);
+        if (!handle)
+            throw new Error(`Workbook "${name}" not found. Open workbooks: ${this.listWorkbooks().join(', ') || '(none)'}`);
+        return handle;
+    }
+}
+//# sourceMappingURL=sheet-engine.js.map

package/dist/custom/new-sheet/sheet-exec.js

@@ -0,0 +1,219 @@
+/**
+ * Sheet exec tool — execute TypeScript code against a headless spreadsheet engine.
+ *
+ * Drop-in replacement for excel-exec (COM). Same tool name (excel_exec),
+ * same schema shape, but runs code in-process against @shortcut/sdk's
+ * HeadlessEngine via a VM sandbox.
+ *
+ * Workbook lifecycle mirrors COM: workbooks persist across executions,
+ * are referenced by name (basename for loaded files, "Book1" etc. for new),
+ * and the agent manages open/create/save/close explicitly.
+ *
+ * Mutation tracking via Proxy wrappers records every setCell/clearData call.
+ * After execution, mutations are resolved to CellEdit[] and formatted into
+ * the same cell diff summary the COM path produces.
+ *
+ * Code is TypeScript (transpiled to JS before execution).
+ */
+import { Type } from '@sinclair/typebox';
+import * as vm from 'node:vm';
+import * as ts from 'typescript';
+import { truncateOutput } from '../../core/tools/truncate.js';
+import { EXCEL_EXEC } from '../../tool-names.js';
+import { Text } from '../../tui/index.js';
+import { formatNotation, parseExcelLocation } from '../tools/excel-range.js';
+import { highlightCode } from '../tools/render-helpers.js';
+import { getDirtyCellSummary } from './cell-diff/index.js';
+import { MutationTracker } from './mutation-tracker.js';
+import { buildSandbox } from './sandbox-globals.js';
+// ---------------------------------------------------------------------------
+// TS transpilation
+// ---------------------------------------------------------------------------
+function transpileTS(code) {
+    const result = ts.transpileModule(code, {
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.CommonJS,
+            strict: false,
+            esModuleInterop: true,
+            allowJs: true
+        }
+    });
+    return result.outputText;
+}
+// ---------------------------------------------------------------------------
+// Console capture
+// ---------------------------------------------------------------------------
+function createCapturedConsole() {
+    const logs = [];
+    const push = (...args) => {
+        logs.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+    };
+    const noop = () => { };
+    const console = {
+        log: push,
+        info: push,
+        warn: push,
+        error: push,
+        debug: noop,
+        trace: noop,
+        dir: noop,
+        table: noop,
+        time: noop,
+        timeEnd: noop,
+        timeLog: noop,
+        clear: noop,
+        count: noop,
+        countReset: noop,
+        group: noop,
+        groupEnd: noop,
+        groupCollapsed: noop,
+        assert: noop
+    };
+    return { console, getLogs: () => logs };
+}
+// ---------------------------------------------------------------------------
+// Tool description
+// ---------------------------------------------------------------------------
+const TOOL_DESCRIPTION = `\
+Execute TypeScript code against the spreadsheet engine. All spreadsheet interactions go through this tool.
+Globals: \`workbook\`, \`worksheet\`, \`console.log()\`. All methods are async — use await.
+
+### Code Discipline
+- **Do NOT call wb.calculate()** — formulas recalculate automatically after each mutation. Forcing recalc breaks things.
+- Keep each code block under 100 lines
+- Use console.log() to return values
+- Always use batched APIs over loops for batch reads and writes
+- Stop retrying after 2 attempts for unexplained failures
+`;
+const schema = Type.Object({
+    description: Type.String({
+        description: 'Short description of what the code does for non-technical users. You MUST reference ranges for any read / write operation. Use this notation for reads and writes, including the brackets: <Workbook:Sheet!Range>. Omit range if operating on the whole sheet or workbook.'
+    }),
+    code: Type.String({
+        description: 'TypeScript code to execute. `workbook` and `worksheet` are already available. Use console.log() to return values. All API methods are async — use await.'
+    })
+});
+// ---------------------------------------------------------------------------
+// Tool factory
+// ---------------------------------------------------------------------------
+export function createSheetExecTool(pool) {
+    return {
+        name: EXCEL_EXEC,
+        label: 'Sheet exec',
+        description: TOOL_DESCRIPTION,
+        parameters: schema,
+        renderCall(args, options, theme) {
+            const desc = typeof args?.description === 'string' ? args.description : '';
+            const code = typeof args?.code === 'string' ? args.code : '';
+            let label = desc || 'sheet_exec';
+            const loc = desc ? parseExcelLocation(desc) : null;
+            if (loc) {
+                const notation = formatNotation(loc);
+                if (notation) {
+                    const styled = theme.fg('accent', notation);
+                    const bracketedIdx = label.indexOf(`<${notation}>`);
+                    if (bracketedIdx >= 0) {
+                        label = label.replace(`<${notation}>`, styled);
+                    }
+                    else {
+                        label = label.replace(notation, styled);
+                    }
+                }
+            }
+            const title = theme.fg('toolTitle', theme.bold(`⊞ ${label}`));
+            if (!options.expanded) {
+                return new Text(title, 0, 0);
+            }
+            if (!code) {
+                return new Text(`${title}\n\n${theme.fg('toolOutput', '...')}`, 0, 0);
+            }
+            const highlighted = highlightCode(code, 'typescript');
+            return new Text(`${title}\n\n${highlighted.join('\n')}`, 0, 0);
+        },
+        renderResult(result, options, theme) {
+            if (!options.expanded)
+                return undefined;
+            const textBlocks = result.content?.filter((c) => c.type === 'text') || [];
+            const output = textBlocks.map((c) => ('text' in c ? c.text : '') || '').join('\n');
+            if (!output)
+                return undefined;
+            return new Text(theme.fg('toolOutput', output), 0, 0);
+        },
+        async execute(_toolCallId, { code, description: _description }, _signal) {
+            // Transpile TS → JS
+            let jsCode;
+            try {
+                jsCode = transpileTS(code);
+            }
+            catch (err) {
+                const msg = `TypeScript compilation error: ${err instanceof Error ? err.message : String(err)}`;
+                return {
+                    content: [{ type: 'text', text: msg }],
+                    details: { ok: false, error: msg }
+                };
+            }
+            // Wrap in async IIFE for top-level await
+            const wrappedCode = `(async () => {\n${jsCode}\n})()`;
+            // Build sandbox
+            const { console: sandboxConsole, getLogs } = createCapturedConsole();
+            const tracker = new MutationTracker();
+            const sandbox = buildSandbox({ pool, tracker, console: sandboxConsole });
+            const context = vm.createContext(sandbox);
+            let output;
+            let error;
+            try {
+                const script = new vm.Script(wrappedCode, { filename: 'agent-code.js' });
+                output = await script.runInContext(context, { timeout: 30_000 });
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+            }
+            // Resolve dirty cells from tracked mutations.
+            // Each mutation stores its workbook ref, so multi-workbook scenarios work.
+            const cellEdits = await tracker.resolve();
+            const editRanges = cellEdits.map((e) => `${e.sheet}!${e.address}`);
+            // Build content text: console logs + cell diff summary
+            const logs = getLogs();
+            const parts = [];
+            if (logs.length > 0) {
+                parts.push(logs.join('\n'));
+            }
+            const cellDiffSummary = getDirtyCellSummary(cellEdits);
+            if (cellDiffSummary) {
+                parts.push(cellDiffSummary);
+            }
+            if (parts.length === 0 && output != null) {
+                parts.push(String(output));
+            }
+            const contentText = parts.join('\n\n') || '(no output)';
+            if (error) {
+                const errorText = error;
+                const fullText = cellDiffSummary ? `${errorText}\n\n${cellDiffSummary}` : errorText;
+                return {
+                    content: [{ type: 'text', text: fullText }],
+                    details: {
+                        ok: false,
+                        error,
+                        logs,
+                        change_count: cellEdits.length,
+                        edit_ranges: editRanges,
+                        dirty_cells: cellEdits
+                    }
+                };
+            }
+            return {
+                content: [{ type: 'text', text: truncateOutput(contentText) }],
+                details: {
+                    ok: true,
+                    output: contentText,
+                    logs,
+                    change_count: cellEdits.length,
+                    edit_ranges: editRanges,
+                    dirty_cells: cellEdits
+                }
+            };
+        }
+    };
+}
+//# sourceMappingURL=sheet-exec.js.map

package/dist/custom/new-sheet-command.js

@@ -0,0 +1,24 @@
+/**
+ * /new-sheet slash command handler.
+ *
+ * Toggles the headless Rust sheet engine on or off.
+ * Requires a restart to take effect.
+ */
+export async function handleNewSheetCommand(showStatus, select, settingsManager) {
+    const current = settingsManager.getNewSheet();
+    const options = [
+        current ? 'Enable (current)' : 'Enable',
+        current ? 'Disable' : 'Disable (current)',
+        'Cancel'
+    ];
+    const choice = await select('New Sheet Engine', options);
+    if (!choice || choice === 'Cancel')
+        return true;
+    const enable = choice.startsWith('Enable');
+    if (enable !== current) {
+        settingsManager.setNewSheet(enable);
+        showStatus(`New sheet engine ${enable ? 'enabled' : 'disabled'} — restart session to take effect`);
+    }
+    return true;
+}
+//# sourceMappingURL=new-sheet-command.js.map

package/dist/custom/preflight.js

@@ -25,8 +25,16 @@ import { getStableXllDir } from './sync-xll.js';
  */
 function refreshPath() {
     try {
-        const user = spawnSync('reg', ['query', 'HKCU\\Environment', '/v', 'Path'], { encoding: 'utf-8', timeout: 5_000 });
-        const system = spawnSync('reg', ['query', 'HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment', '/v', 'Path'], { encoding: 'utf-8', timeout: 5_000 });
+        const user = spawnSync('reg', ['query', 'HKCU\\Environment', '/v', 'Path'], {
+            encoding: 'utf-8',
+            timeout: 5_000
+        });
+        const system = spawnSync('reg', [
+            'query',
+            'HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment',
+            '/v',
+            'Path'
+        ], { encoding: 'utf-8', timeout: 5_000 });
         const extract = (out) => (out.match(/REG_(?:EXPAND_)?SZ\s+(.+)/i)?.[1] ?? '')
             .split(';')
             .map((p) => p.trim())
@@ -72,7 +80,10 @@ function header(step) {
 function prompt(text) {
     return new Promise((res) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
-        rl.question(text, (answer) => { rl.close(); res(answer); });
+        rl.question(text, (answer) => {
+            rl.close();
+            res(answer);
+        });
     });
 }
 function promptEnter(message) {
@@ -211,9 +222,12 @@ async function ensurePipPackages() {
     const pipStampFile = join(getStableXllDir(), '.pip-version');
     let pipUpToDate = false;
     try {
-        pipUpToDate = existsSync(pipStampFile) && readFileSync(pipStampFile, 'utf-8').trim() === VERSION;
+        pipUpToDate =
+            existsSync(pipStampFile) && readFileSync(pipStampFile, 'utf-8').trim() === VERSION;
+    }
+    catch {
+        /* proceed with install */
     }
-    catch { /* proceed with install */ }
     if (pipUpToDate) {
         ok('Packages already installed.');
         return;
@@ -225,7 +239,9 @@ async function ensurePipPackages() {
         try {
             writeFileSync(pipStampFile, VERSION, 'utf-8');
         }
-        catch { /* non-fatal */ }
+        catch {
+            /* non-fatal */
+        }
     }
     else {
         warn('Package install had issues — the setup agent will help.');
@@ -362,20 +378,14 @@ async function ensureExcelAndXll() {
     const excelRunning = tasklist.ok && tasklist.stdout.includes('EXCEL.EXE');
     if (excelRunning) {
         warn('Excel is running but ShortcutXL is not loaded.');
-        await promptEnter('Please close Excel completely, then press Enter. We will reopen it for you.');
-        // Wait briefly for Excel to fully exit
-        for (let i = 0; i < 5; i++) {
-            const check = run('tasklist /FI "IMAGENAME eq EXCEL.EXE" /NH');
-            if (!check.ok || !check.stdout.includes('EXCEL.EXE'))
-                break;
-            await new Promise((r) => setTimeout(r, 1000));
-        }
+        log('Please close Excel completely, then reopen it.');
+    }
+    else {
+        log('Please open Excel.');
     }
-    // Launch Excel ourselves — the XLL is registered and will auto-load
-    log('Opening Excel...');
     clearXllSessionCache(); // New Excel instance = new bearer token
-    cpSpawn('cmd', ['/c', 'start', 'excel'], { detached: true, stdio: 'ignore' }).unref();
-    log('Waiting for ShortcutXL to start...');
+    await promptEnter('Press Enter once Excel is open.');
+    log('Checking for ShortcutXL...');
     for (let i = 0; i < 15; i++) {
         await new Promise((r) => setTimeout(r, 1000));
         process.stderr.write(`\r  ${chalk.cyan(SPINNER_FRAMES[i % SPINNER_FRAMES.length])} Waiting for ShortcutXL... (${i + 1}s)\x1b[K`);

package/dist/custom/prompts/action.js

@@ -10,16 +10,38 @@
  * via the health check endpoint or excel_exec.
  */
 import { join, resolve } from 'path';
-import { getAgentDir, getBundledSkillsDir, getInstalledMarkerPath, getPackageDir, getSessionsDir } from '../../config.js';
+import { getAgentDir, getBundledSkillsDir, getInstalledMarkerPath, getPackageDir, getSessionsDir, isNewSheetEnabled } from '../../config.js';
 import { loadSkills } from '../../core/skills.js';
 import { EXCEL_HTTP_URL } from '../constants.js';
+import { getSheetApiGuidelines } from '../new-sheet/api-guidelines.js';
 import { EXCEL_COM_API_GUIDELINES } from './api.js';
 import { CODING_GUIDELINES, COMMUNICATION_GUIDELINES, DATA_FORMATTING_GUIDELINES, EXPLORATION_GUIDELINES, NOTES_COMMENTS_GUIDELINES, NUMBER_FORMAT_REFERENCE } from './shared.js';
 // ---------------------------------------------------------------------------
+// Engine variants — COM (Excel desktop) vs New Sheet (headless Rust engine)
+// ---------------------------------------------------------------------------
+const COM_PROMPTS = {
+    execTool: `- an HTTP server at ${EXCEL_HTTP_URL} is run inside the Excel process. Auto-reloads via the registry when Excel starts`,
+    bashTool: `- runs a separate Python subprocess
+- write python files in the modules directory to create UDFs (User-Defined Function). See your xll docs for more information
+- health check: curl ${EXCEL_HTTP_URL}/config (not possible in a sandbox, just run simple commands via excel_exec)`,
+    apiGuidelines: EXCEL_COM_API_GUIDELINES
+};
+const NEW_SHEET_PROMPTS = {
+    execTool: `- runs TypeScript code against a headless spreadsheet engine (in-process Rust compute core)
+- lifecycle: createWorkbook(), loadWorkbook(path), getWorkbook(name), listWorkbooks(), saveWorkbook(path), closeWorkbook(name)
+- convenience globals: \`workbook\` (most recent Workbook) and \`worksheet\` (its active Worksheet). All methods are async — use await
+- workbooks persist across calls (like Excel staying open). Variables don't.
+- use console.log() to return values`,
+    bashTool: `- runs a separate subprocess for shell commands, file operations, etc.`,
+    get apiGuidelines() {
+        return getSheetApiGuidelines();
+    }
+};
+// ---------------------------------------------------------------------------
 // Prompt sections — all static content lives here as module-level constants.
 // The function at the bottom only resolves runtime paths and assembles them.
 // ---------------------------------------------------------------------------
-const CORE = () => `\
+const CORE = (newSheet) => `\
 Your name is Shortcut, an expert financial spreadsheet assistant that lives on the user's computer with Excel superpowers
 Deliver professional-grade results with precise calculations, consistent formatting, and proper validation for business professionals
 Current date: ${new Date().toISOString().slice(0, 10)}. Use this as single source of truth for time, overriding pretrained knowledge. Verify recency with tools for time-sensitive facts.
@@ -29,18 +51,15 @@ Avoid over-interpretation and don't be extra. Only make changes that are directl
 Keep solutions simple and focused. For example, don't add extra sheets, reformat untouched areas, or make "improvements" beyond what was asked
 
 ## Tools
-excel_exec: use it for all Excel interactions
-- an HTTP server at ${EXCEL_HTTP_URL} is run inside the Excel process. Auto-reloads via the registry when Excel starts
+excel_exec: use it for all spreadsheet interactions
+${newSheet ? NEW_SHEET_PROMPTS.execTool : COM_PROMPTS.execTool}
 
 bash: use it for everything else, including python
-- runs a separate Python subprocess
-- write python files in the modules directory to create UDFs (User-Defined Function). See your xll docs for more information
-- health check: curl ${EXCEL_HTTP_URL}/config (not possible in a sandbox, just run simple commands via excel_exec)
+${newSheet ? NEW_SHEET_PROMPTS.bashTool : COM_PROMPTS.bashTool}
 
 
 Attachments, Read-Only Operations
-- The general principle is to avoid cluttering the user's Excel with files they don't need to see or edit
-- Use COM for reading operations, but given that it displays on the user's desktop, read one file at a time
+- Avoid cluttering the user's Excel with files they don't need to see or edit. Read one file at a time
 
 PDF Processing:
 - You MUST ALWAYS use document readers to understand and extract data from PDFs, no matter if it is programmatic extraction or multimodal extraction.
@@ -65,7 +84,8 @@ Excel Processing:
 For any extension requests, ask the user which approach fits their need, or recommend one based on context. Prefer skills by default — they're lightweight and don't pollute context
 - UDF: a live Excel formula. Best when: the user wants formulas that recalculates live
 - Skill: md file with instructions the agent reads and follows. Progressively disclosed so it don't overload agent context. Best when the user wants a reusable workflow or procedure.
-- Extension / Custom Tool: a new tool always loaded into the agent, callable in a single step. Reserve for integrations the user calls constantly (e.g. an internal API used daily). Best when the user needs something invoked often and speed matters`;
+- Extension / Custom Tool: a new tool always loaded into the agent, callable in a single step. Reserve for integrations the user calls constantly (e.g. an internal API used daily). Best when the user needs something invoked often and speed matters
+- When building extensions, ALWAYS read the relevant examples in agent-docs/examples/extensions/ first (e.g. tools.ts, interactive-shell.ts). They contain battle-tested patterns for subprocess spawning, tool registration, shell escaping, etc. Do not write extensions from scratch.`;
 const INSTALLATION = (markerPath) => `\
 ## Installation
 The installed marker file is at \`${markerPath}\`. If the user needs to re-run installation (e.g. something is broken), delete this file and use switch_mode to switch to "installation" mode`;
@@ -122,6 +142,7 @@ const SKILLS = (skills, userSkillsDir) => {
 // Assembly — resolves runtime paths, loads skills, joins sections
 // ---------------------------------------------------------------------------
 export function buildActionPrompt() {
+    const newSheet = isNewSheetEnabled();
     const agentDir = getAgentDir();
     const agentDocsDir = resolve(join(getPackageDir(), 'agent-docs'));
     const installedMarker = getInstalledMarkerPath();
@@ -129,7 +150,7 @@ export function buildActionPrompt() {
     const { skills } = loadSkills({ agentDir, skillPaths: [getBundledSkillsDir()] });
     const skillsSection = SKILLS(skills, userSkillsDir);
     const sections = [
-        CORE(),
+        CORE(newSheet),
         INSTALLATION(installedMarker),
         SELF_REFERENCE({
             packageDir: getPackageDir(),
@@ -145,7 +166,7 @@ export function buildActionPrompt() {
             examples: join(agentDocsDir, 'examples')
         })
     ];
-    sections.push(skillsSection, COMMUNICATION_GUIDELINES, CODING_GUIDELINES, EXPLORATION_GUIDELINES, DATA_FORMATTING_GUIDELINES, NUMBER_FORMAT_REFERENCE, NOTES_COMMENTS_GUIDELINES, EXCEL_COM_API_GUIDELINES);
+    sections.push(skillsSection, COMMUNICATION_GUIDELINES, CODING_GUIDELINES, EXPLORATION_GUIDELINES, DATA_FORMATTING_GUIDELINES, NUMBER_FORMAT_REFERENCE, NOTES_COMMENTS_GUIDELINES, newSheet ? NEW_SHEET_PROMPTS.apiGuidelines : COM_PROMPTS.apiGuidelines);
     return sections.join('\n\n');
 }
 //# sourceMappingURL=action.js.map

package/dist/custom/prompts/shared.js

@@ -90,12 +90,6 @@ Add Excel notes/comments when:
 - For uncertainty, also highlight the value cell yellow for visual scanning
 
 Do NOT add notes for routine formulas or obvious calculations
-
-**COM API for notes:**
-- Add: \`ws.Range("A1").AddComment("text")\` (or \`.NoteText("text")\` for older-style notes)
-- Read: \`ws.Range("A1").Comment.Text()\`
-- Delete: \`ws.Range("A1").Comment.Delete()\`
-- Check existence: \`ws.Range("A1").Comment is not None\`
 `;
 export const COMMUNICATION_GUIDELINES = `
 ======================

package/dist/custom/providers/llm-usage.js

@@ -33,10 +33,6 @@ export function buildUsage(rawUsage, model) {
 }
 /** Map backend stop_reason strings to pi-ai StopReason values. */
 export function mapStopReason(raw) {
-    return raw === 'tool_use'
-        ? 'toolUse'
-        : raw === 'max_tokens'
-            ? 'length'
-            : 'stop';
+    return raw === 'tool_use' ? 'toolUse' : raw === 'max_tokens' ? 'length' : 'stop';
 }
 //# sourceMappingURL=llm-usage.js.map

package/dist/custom/providers/shortcut-invoke.js

@@ -28,9 +28,9 @@ export function createShortcutInvoke(baseUrl, getExtraHeaders) {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',
+                        ...getExtraHeaders?.(),
                         Authorization: `Bearer ${apiKey}`,
-                        'User-Agent': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`,
-                        ...getExtraHeaders?.()
+                        'User-Agent': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`
                     },
                     body: JSON.stringify(body),
                     signal: options?.signal
@@ -91,8 +91,7 @@ export function createShortcutInvoke(baseUrl, getExtraHeaders) {
                 });
             }
             catch (err) {
-                const isAbort = options?.signal?.aborted ||
-                    (err instanceof Error && err.name === 'AbortError');
+                const isAbort = options?.signal?.aborted || (err instanceof Error && err.name === 'AbortError');
                 const errMsg = err instanceof Error ? err.message : 'Request failed';
                 const errorMessage = {
                     role: 'assistant',

package/dist/custom/providers/shortcut-stream.js

@@ -49,9 +49,9 @@ export function createShortcutStream(baseUrl, getExtraHeaders) {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',
+                        ...getExtraHeaders?.(),
                         Authorization: `Bearer ${apiKey}`,
-                        'User-Agent': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`,
-                        ...getExtraHeaders?.()
+                        'User-Agent': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`
                     },
                     body: JSON.stringify(body),
                     signal: options?.signal
@@ -94,8 +94,7 @@ export function createShortcutStream(baseUrl, getExtraHeaders) {
                 }
             }
             catch (err) {
-                const isAbort = options?.signal?.aborted ||
-                    (err instanceof Error && err.name === 'AbortError');
+                const isAbort = options?.signal?.aborted || (err instanceof Error && err.name === 'AbortError');
                 const errMsg = err instanceof Error ? err.message : 'Request failed';
                 partial.stopReason = isAbort ? 'aborted' : 'error';
                 partial.errorMessage = isAbort ? 'Request was aborted' : errMsg;