thaddeus 1.0.26 → 1.0.28

package/src/commands/context/context-noninteractive.js

@@ -0,0 +1,219 @@
+import { feature } from 'bun:bundle';
+import { microcompactMessages } from '../../services/compact/microCompact.js';
+import { analyzeContextUsage, } from '../../utils/analyzeContext.js';
+import { formatTokens } from '../../utils/format.js';
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js';
+import { getSourceDisplayName } from '../../utils/settings/constants.js';
+import { plural } from '../../utils/stringUtils.js';
+export async function collectContextData(context) {
+    const { messages, getAppState, options: { mainLoopModel, tools, agentDefinitions, customSystemPrompt, appendSystemPrompt, }, } = context;
+    let apiView = getMessagesAfterCompactBoundary(messages);
+    if (feature('CONTEXT_COLLAPSE')) {
+        /* eslint-disable @typescript-eslint/no-require-imports */
+        const { projectView } = require('../../services/contextCollapse/operations.js');
+        /* eslint-enable @typescript-eslint/no-require-imports */
+        apiView = projectView(apiView);
+    }
+    const { messages: compactedMessages } = await microcompactMessages(apiView);
+    const appState = getAppState();
+    return analyzeContextUsage(compactedMessages, mainLoopModel, async () => appState.toolPermissionContext, tools, agentDefinitions, undefined, // terminalWidth
+    // analyzeContextUsage only reads options.{customSystemPrompt,appendSystemPrompt}
+    // but its signature declares the full Pick<ToolUseContext, 'options'>.
+    { options: { customSystemPrompt, appendSystemPrompt } }, undefined, // mainThreadAgentDefinition
+    apiView);
+}
+export async function call(_args, context) {
+    const data = await collectContextData(context);
+    return {
+        type: 'text',
+        value: formatContextAsMarkdownTable(data),
+    };
+}
+function formatContextAsMarkdownTable(data) {
+    const { categories, totalTokens, rawMaxTokens, percentage, model, memoryFiles, mcpTools, agents, skills, messageBreakdown, systemTools, systemPromptSections, } = data;
+    let output = `## Context Usage\n\n`;
+    output += `**Model:** ${model}  \n`;
+    output += `**Tokens:** ${formatTokens(totalTokens)} / ${formatTokens(rawMaxTokens)} (${percentage}%)\n`;
+    // Context-collapse status. Always show when the runtime gate is on —
+    // the user needs to know which strategy is managing their context
+    // even before anything has fired.
+    if (feature('CONTEXT_COLLAPSE')) {
+        /* eslint-disable @typescript-eslint/no-require-imports */
+        const { getStats, isContextCollapseEnabled } = require('../../services/contextCollapse/index.js');
+        /* eslint-enable @typescript-eslint/no-require-imports */
+        if (isContextCollapseEnabled()) {
+            const s = getStats();
+            const { health: h } = s;
+            const parts = [];
+            if (s.collapsedSpans > 0) {
+                parts.push(`${s.collapsedSpans} ${plural(s.collapsedSpans, 'span')} summarized (${s.collapsedMessages} messages)`);
+            }
+            if (s.stagedSpans > 0)
+                parts.push(`${s.stagedSpans} staged`);
+            const summary = parts.length > 0
+                ? parts.join(', ')
+                : h.totalSpawns > 0
+                    ? `${h.totalSpawns} ${plural(h.totalSpawns, 'spawn')}, nothing staged yet`
+                    : 'waiting for first trigger';
+            output += `**Context strategy:** collapse (${summary})\n`;
+            if (h.totalErrors > 0) {
+                output += `**Collapse errors:** ${h.totalErrors}/${h.totalSpawns} spawns failed`;
+                if (h.lastError) {
+                    output += ` (last: ${h.lastError.slice(0, 80)})`;
+                }
+                output += '\n';
+            }
+            else if (h.emptySpawnWarningEmitted) {
+                output += `**Collapse idle:** ${h.totalEmptySpawns} consecutive empty runs\n`;
+            }
+        }
+    }
+    output += '\n';
+    // Main categories table
+    const visibleCategories = categories.filter(cat => cat.tokens > 0 &&
+        cat.name !== 'Free space' &&
+        cat.name !== 'Autocompact buffer');
+    if (visibleCategories.length > 0) {
+        output += `### Estimated usage by category\n\n`;
+        output += `| Category | Tokens | Percentage |\n`;
+        output += `|----------|--------|------------|\n`;
+        for (const cat of visibleCategories) {
+            const percentDisplay = ((cat.tokens / rawMaxTokens) * 100).toFixed(1);
+            output += `| ${cat.name} | ${formatTokens(cat.tokens)} | ${percentDisplay}% |\n`;
+        }
+        const freeSpaceCategory = categories.find(c => c.name === 'Free space');
+        if (freeSpaceCategory && freeSpaceCategory.tokens > 0) {
+            const percentDisplay = ((freeSpaceCategory.tokens / rawMaxTokens) *
+                100).toFixed(1);
+            output += `| Free space | ${formatTokens(freeSpaceCategory.tokens)} | ${percentDisplay}% |\n`;
+        }
+        const autocompactCategory = categories.find(c => c.name === 'Autocompact buffer');
+        if (autocompactCategory && autocompactCategory.tokens > 0) {
+            const percentDisplay = ((autocompactCategory.tokens / rawMaxTokens) *
+                100).toFixed(1);
+            output += `| Autocompact buffer | ${formatTokens(autocompactCategory.tokens)} | ${percentDisplay}% |\n`;
+        }
+        output += `\n`;
+    }
+    // MCP tools
+    if (mcpTools.length > 0) {
+        output += `### MCP Tools\n\n`;
+        output += `| Tool | Server | Tokens |\n`;
+        output += `|------|--------|--------|\n`;
+        for (const tool of mcpTools) {
+            output += `| ${tool.name} | ${tool.serverName} | ${formatTokens(tool.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    // System tools (ant-only)
+    if (systemTools &&
+        systemTools.length > 0 &&
+        process.env.USER_TYPE === 'ant') {
+        output += `### [ANT-ONLY] System Tools\n\n`;
+        output += `| Tool | Tokens |\n`;
+        output += `|------|--------|\n`;
+        for (const tool of systemTools) {
+            output += `| ${tool.name} | ${formatTokens(tool.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    // System prompt sections (ant-only)
+    if (systemPromptSections &&
+        systemPromptSections.length > 0 &&
+        process.env.USER_TYPE === 'ant') {
+        output += `### [ANT-ONLY] System Prompt Sections\n\n`;
+        output += `| Section | Tokens |\n`;
+        output += `|---------|--------|\n`;
+        for (const section of systemPromptSections) {
+            output += `| ${section.name} | ${formatTokens(section.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    // Custom agents
+    if (agents.length > 0) {
+        output += `### Custom Agents\n\n`;
+        output += `| Agent Type | Source | Tokens |\n`;
+        output += `|------------|--------|--------|\n`;
+        for (const agent of agents) {
+            let sourceDisplay;
+            switch (agent.source) {
+                case 'projectSettings':
+                    sourceDisplay = 'Project';
+                    break;
+                case 'userSettings':
+                    sourceDisplay = 'User';
+                    break;
+                case 'localSettings':
+                    sourceDisplay = 'Local';
+                    break;
+                case 'flagSettings':
+                    sourceDisplay = 'Flag';
+                    break;
+                case 'policySettings':
+                    sourceDisplay = 'Policy';
+                    break;
+                case 'plugin':
+                    sourceDisplay = 'Plugin';
+                    break;
+                case 'built-in':
+                    sourceDisplay = 'Built-in';
+                    break;
+                default:
+                    sourceDisplay = String(agent.source);
+            }
+            output += `| ${agent.agentType} | ${sourceDisplay} | ${formatTokens(agent.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    // Memory files
+    if (memoryFiles.length > 0) {
+        output += `### Memory Files\n\n`;
+        output += `| Type | Path | Tokens |\n`;
+        output += `|------|------|--------|\n`;
+        for (const file of memoryFiles) {
+            output += `| ${file.type} | ${file.path} | ${formatTokens(file.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    // Skills
+    if (skills && skills.tokens > 0 && skills.skillFrontmatter.length > 0) {
+        output += `### Skills\n\n`;
+        output += `| Skill | Source | Tokens |\n`;
+        output += `|-------|--------|--------|\n`;
+        for (const skill of skills.skillFrontmatter) {
+            output += `| ${skill.name} | ${getSourceDisplayName(skill.source)} | ${formatTokens(skill.tokens)} |\n`;
+        }
+        output += `\n`;
+    }
+    // Message breakdown (ant-only)
+    if (messageBreakdown && process.env.USER_TYPE === 'ant') {
+        output += `### [ANT-ONLY] Message Breakdown\n\n`;
+        output += `| Category | Tokens |\n`;
+        output += `|----------|--------|\n`;
+        output += `| Tool calls | ${formatTokens(messageBreakdown.toolCallTokens)} |\n`;
+        output += `| Tool results | ${formatTokens(messageBreakdown.toolResultTokens)} |\n`;
+        output += `| Attachments | ${formatTokens(messageBreakdown.attachmentTokens)} |\n`;
+        output += `| Assistant messages (non-tool) | ${formatTokens(messageBreakdown.assistantMessageTokens)} |\n`;
+        output += `| User messages (non-tool-result) | ${formatTokens(messageBreakdown.userMessageTokens)} |\n`;
+        output += `\n`;
+        if (messageBreakdown.toolCallsByType.length > 0) {
+            output += `#### Top Tools\n\n`;
+            output += `| Tool | Call Tokens | Result Tokens |\n`;
+            output += `|------|-------------|---------------|\n`;
+            for (const tool of messageBreakdown.toolCallsByType) {
+                output += `| ${tool.name} | ${formatTokens(tool.callTokens)} | ${formatTokens(tool.resultTokens)} |\n`;
+            }
+            output += `\n`;
+        }
+        if (messageBreakdown.attachmentsByType.length > 0) {
+            output += `#### Top Attachments\n\n`;
+            output += `| Attachment | Tokens |\n`;
+            output += `|------------|--------|\n`;
+            for (const attachment of messageBreakdown.attachmentsByType) {
+                output += `| ${attachment.name} | ${formatTokens(attachment.tokens)} |\n`;
+            }
+            output += `\n`;
+        }
+    }
+    return output;
+}

package/src/commands/context/context.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { feature } from 'bun:bundle';
+import * as React from 'react';
+import { ContextVisualization } from '../../components/ContextVisualization.js';
+import { microcompactMessages } from '../../services/compact/microCompact.js';
+import { analyzeContextUsage } from '../../utils/analyzeContext.js';
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js';
+import { renderToAnsiString } from '../../utils/staticRender.js';
+/**
+ * Apply the same context transforms query.ts does before the API call, so
+ * /context shows what the model actually sees rather than the REPL's raw
+ * history. Without projectView the token count overcounts by however much
+ * was collapsed — user sees "180k, 3 spans collapsed" when the API sees 120k.
+ */
+function toApiView(messages) {
+    let view = getMessagesAfterCompactBoundary(messages);
+    if (feature('CONTEXT_COLLAPSE')) {
+        /* eslint-disable @typescript-eslint/no-require-imports */
+        const { projectView } = require('../../services/contextCollapse/operations.js');
+        /* eslint-enable @typescript-eslint/no-require-imports */
+        view = projectView(view);
+    }
+    return view;
+}
+export async function call(onDone, context) {
+    const { messages, getAppState, options: { mainLoopModel, tools } } = context;
+    const apiView = toApiView(messages);
+    // Apply microcompact to get accurate representation of messages sent to API
+    const { messages: compactedMessages } = await microcompactMessages(apiView);
+    // Get terminal width for responsive sizing
+    const terminalWidth = process.stdout.columns || 80;
+    const appState = getAppState();
+    // Analyze context with compacted messages
+    // Pass original messages as last parameter for accurate API usage extraction
+    const data = await analyzeContextUsage(compactedMessages, mainLoopModel, async () => appState.toolPermissionContext, tools, appState.agentDefinitions, terminalWidth, context, 
+    // Pass full context for system prompt calculation
+    undefined, 
+    // mainThreadAgentDefinition
+    apiView // Original messages for API usage extraction
+    );
+    // Render to ANSI string to preserve colors and pass to onDone like local commands do
+    const output = await renderToAnsiString(_jsx(ContextVisualization, { data: data }));
+    onDone(output);
+    return null;
+}

package/src/commands/context/index.js

@@ -0,0 +1,21 @@
+import { getIsNonInteractiveSession } from '../../bootstrap/state.js';
+export const context = {
+    name: 'context',
+    description: 'Visualize current context usage as a colored grid',
+    isEnabled: () => !getIsNonInteractiveSession(),
+    type: 'local-jsx',
+    load: () => import('./context.js'),
+};
+export const contextNonInteractive = {
+    type: 'local',
+    name: 'context',
+    supportsNonInteractive: true,
+    description: 'Show current context usage',
+    get isHidden() {
+        return !getIsNonInteractiveSession();
+    },
+    isEnabled() {
+        return getIsNonInteractiveSession();
+    },
+    load: () => import('./context-noninteractive.js'),
+};

package/src/commands/coordinator.js

@@ -0,0 +1,34 @@
+import { logEvent, } from '../services/analytics/index.js';
+import { isCoordinatorMode } from '../coordinator/coordinatorMode.js';
+const coordinator = {
+    type: 'local-jsx',
+    name: 'coordinator',
+    aliases: ['coord'],
+    description: 'Toggle Coordinator Mode — orchestrate tasks across worker agents',
+    isEnabled: () => true,
+    immediate: true,
+    load: () => Promise.resolve({
+        async call(onDone, _context) {
+            const currentlyOn = isCoordinatorMode();
+            const newState = !currentlyOn;
+            if (newState) {
+                process.env.THADDEUS_COORDINATOR_MODE = '1';
+            }
+            else {
+                delete process.env.THADDEUS_COORDINATOR_MODE;
+            }
+            logEvent('thaddeus_coordinator_mode_toggled', {
+                enabled: newState,
+                source: 'slash_command',
+            });
+            const metaMessages = [
+                `<system-reminder>\n${newState
+                    ? 'Coordinator Mode enabled. You are now a coordinator — spawn workers via the Agent tool, synthesize their results, and direct follow-up work. Do not do implementation yourself.'
+                    : 'Coordinator Mode disabled. You are back to normal mode — handle tasks directly using your own tools.'}\n</system-reminder>`,
+            ];
+            onDone(newState ? 'Coordinator Mode enabled' : 'Coordinator Mode disabled', { display: 'system', metaMessages });
+            return null;
+        },
+    }),
+};
+export default coordinator;

package/src/commands/copy/copy.js

@@ -0,0 +1,366 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { mkdir, writeFile } from 'fs/promises';
+import { marked } from 'marked';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import React, { useRef } from 'react';
+import { Select } from '../../components/CustomSelect/select.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { Pane } from '../../components/design-system/Pane.js';
+import { stringWidth } from '../../ink/stringWidth.js';
+import { setClipboard } from '../../ink/termio/osc.js';
+import { Box, Text } from '../../ink.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../utils/config.js';
+import { extractTextContent, stripPromptXMLTags } from '../../utils/messages.js';
+import { countCharInString } from '../../utils/stringUtils.js';
+const COPY_DIR = join(tmpdir(), 'claude');
+const RESPONSE_FILENAME = 'response.md';
+const MAX_LOOKBACK = 20;
+function extractCodeBlocks(markdown) {
+    const tokens = marked.lexer(stripPromptXMLTags(markdown));
+    const blocks = [];
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const codeToken = token;
+            blocks.push({
+                code: codeToken.text,
+                lang: codeToken.lang
+            });
+        }
+    }
+    return blocks;
+}
+/**
+ * Walk messages newest-first, returning text from assistant messages that
+ * actually said something (skips tool-use-only turns and API errors).
+ * Index 0 = latest, 1 = second-to-latest, etc. Caps at MAX_LOOKBACK.
+ */
+export function collectRecentAssistantTexts(messages) {
+    const texts = [];
+    for (let i = messages.length - 1; i >= 0 && texts.length < MAX_LOOKBACK; i--) {
+        const msg = messages[i];
+        if (msg?.type !== 'assistant' || msg.isApiErrorMessage)
+            continue;
+        const content = msg.message.content;
+        if (!Array.isArray(content))
+            continue;
+        const text = extractTextContent(content, '\n\n');
+        if (text)
+            texts.push(text);
+    }
+    return texts;
+}
+export function fileExtension(lang) {
+    if (lang) {
+        // Sanitize to prevent path traversal (e.g. ```../../etc/passwd)
+        // Language identifiers are alphanumeric: python, tsx, jsonc, etc.
+        const sanitized = lang.replace(/[^a-zA-Z0-9]/g, '');
+        if (sanitized && sanitized !== 'plaintext') {
+            return `.${sanitized}`;
+        }
+    }
+    return '.txt';
+}
+async function writeToFile(text, filename) {
+    const filePath = join(COPY_DIR, filename);
+    await mkdir(COPY_DIR, {
+        recursive: true
+    });
+    await writeFile(filePath, text, 'utf-8');
+    return filePath;
+}
+async function copyOrWriteToFile(text, filename) {
+    const raw = await setClipboard(text);
+    if (raw)
+        process.stdout.write(raw);
+    const lineCount = countCharInString(text, '\n') + 1;
+    const charCount = text.length;
+    // Also write to a temp file — clipboard paths are best-effort (OSC 52 needs
+    // terminal support), so the file provides a reliable fallback.
+    try {
+        const filePath = await writeToFile(text, filename);
+        return `Copied to clipboard (${charCount} characters, ${lineCount} lines)\nAlso written to ${filePath}`;
+    }
+    catch {
+        return `Copied to clipboard (${charCount} characters, ${lineCount} lines)`;
+    }
+}
+function truncateLine(text, maxLen) {
+    const firstLine = text.split('\n')[0] ?? '';
+    if (stringWidth(firstLine) <= maxLen) {
+        return firstLine;
+    }
+    let result = '';
+    let width = 0;
+    const targetWidth = maxLen - 1;
+    for (const char of firstLine) {
+        const charWidth = stringWidth(char);
+        if (width + charWidth > targetWidth)
+            break;
+        result += char;
+        width += charWidth;
+    }
+    return result + '\u2026';
+}
+function CopyPicker(t0) {
+    const $ = _c(33);
+    const { fullText, codeBlocks, messageAge, onDone } = t0;
+    const focusedRef = useRef("full");
+    const t1 = `${fullText.length} chars, ${countCharInString(fullText, "\n") + 1} lines`;
+    let t2;
+    if ($[0] !== t1) {
+        t2 = {
+            label: "Full response",
+            value: "full",
+            description: t1
+        };
+        $[0] = t1;
+        $[1] = t2;
+    }
+    else {
+        t2 = $[1];
+    }
+    let t3;
+    if ($[2] !== codeBlocks || $[3] !== t2) {
+        let t4;
+        if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+            t4 = {
+                label: "Always copy full response",
+                value: "always",
+                description: "Skip this picker in the future (revert via /config)"
+            };
+            $[5] = t4;
+        }
+        else {
+            t4 = $[5];
+        }
+        t3 = [t2, ...codeBlocks.map(_temp), t4];
+        $[2] = codeBlocks;
+        $[3] = t2;
+        $[4] = t3;
+    }
+    else {
+        t3 = $[4];
+    }
+    const options = t3;
+    let t4;
+    if ($[6] !== codeBlocks || $[7] !== fullText) {
+        t4 = function getSelectionContent(selected) {
+            if (selected === "full" || selected === "always") {
+                return {
+                    text: fullText,
+                    filename: RESPONSE_FILENAME
+                };
+            }
+            const block_0 = codeBlocks[selected];
+            return {
+                text: block_0.code,
+                filename: `copy${fileExtension(block_0.lang)}`,
+                blockIndex: selected
+            };
+        };
+        $[6] = codeBlocks;
+        $[7] = fullText;
+        $[8] = t4;
+    }
+    else {
+        t4 = $[8];
+    }
+    const getSelectionContent = t4;
+    let t5;
+    if ($[9] !== codeBlocks.length || $[10] !== getSelectionContent || $[11] !== messageAge || $[12] !== onDone) {
+        t5 = async function handleSelect(selected_0) {
+            const content = getSelectionContent(selected_0);
+            if (selected_0 === "always") {
+                if (!getGlobalConfig().copyFullResponse) {
+                    saveGlobalConfig(_temp2);
+                }
+                logEvent("thaddeus_copy", {
+                    block_count: codeBlocks.length,
+                    always: true,
+                    message_age: messageAge
+                });
+                const result = await copyOrWriteToFile(content.text, content.filename);
+                onDone(`${result}\nPreference saved. Use /config to change copyFullResponse`);
+                return;
+            }
+            logEvent("thaddeus_copy", {
+                selected_block: content.blockIndex,
+                block_count: codeBlocks.length,
+                message_age: messageAge
+            });
+            const result_0 = await copyOrWriteToFile(content.text, content.filename);
+            onDone(result_0);
+        };
+        $[9] = codeBlocks.length;
+        $[10] = getSelectionContent;
+        $[11] = messageAge;
+        $[12] = onDone;
+        $[13] = t5;
+    }
+    else {
+        t5 = $[13];
+    }
+    const handleSelect = t5;
+    let t6;
+    if ($[14] !== codeBlocks.length || $[15] !== getSelectionContent || $[16] !== messageAge || $[17] !== onDone) {
+        const handleWrite = async function handleWrite(selected_1) {
+            const content_0 = getSelectionContent(selected_1);
+            logEvent("thaddeus_copy", {
+                selected_block: content_0.blockIndex,
+                block_count: codeBlocks.length,
+                message_age: messageAge,
+                write_shortcut: true
+            });
+            ;
+            try {
+                const filePath = await writeToFile(content_0.text, content_0.filename);
+                onDone(`Written to ${filePath}`);
+            }
+            catch (t7) {
+                const e = t7;
+                onDone(`Failed to write file: ${e instanceof Error ? e.message : e}`);
+            }
+        };
+        t6 = function handleKeyDown(e_0) {
+            if (e_0.key === "w") {
+                e_0.preventDefault();
+                handleWrite(focusedRef.current);
+            }
+        };
+        $[14] = codeBlocks.length;
+        $[15] = getSelectionContent;
+        $[16] = messageAge;
+        $[17] = onDone;
+        $[18] = t6;
+    }
+    else {
+        t6 = $[18];
+    }
+    const handleKeyDown = t6;
+    let t7;
+    if ($[19] === Symbol.for("react.memo_cache_sentinel")) {
+        t7 = _jsx(Text, { dimColor: true, children: "Select content to copy:" });
+        $[19] = t7;
+    }
+    else {
+        t7 = $[19];
+    }
+    let t8;
+    if ($[20] === Symbol.for("react.memo_cache_sentinel")) {
+        t8 = value => {
+            focusedRef.current = value;
+        };
+        $[20] = t8;
+    }
+    else {
+        t8 = $[20];
+    }
+    let t9;
+    if ($[21] !== handleSelect) {
+        t9 = selected_2 => {
+            handleSelect(selected_2);
+        };
+        $[21] = handleSelect;
+        $[22] = t9;
+    }
+    else {
+        t9 = $[22];
+    }
+    let t10;
+    if ($[23] !== onDone) {
+        t10 = () => {
+            onDone("Copy cancelled", {
+                display: "system"
+            });
+        };
+        $[23] = onDone;
+        $[24] = t10;
+    }
+    else {
+        t10 = $[24];
+    }
+    let t11;
+    if ($[25] !== options || $[26] !== t10 || $[27] !== t9) {
+        t11 = _jsx(Select, { options: options, hideIndexes: false, onFocus: t8, onChange: t9, onCancel: t10 });
+        $[25] = options;
+        $[26] = t10;
+        $[27] = t9;
+        $[28] = t11;
+    }
+    else {
+        t11 = $[28];
+    }
+    let t12;
+    if ($[29] === Symbol.for("react.memo_cache_sentinel")) {
+        t12 = _jsx(Text, { dimColor: true, children: _jsxs(Byline, { children: [_jsx(KeyboardShortcutHint, { shortcut: "enter", action: "copy" }), _jsx(KeyboardShortcutHint, { shortcut: "w", action: "write to file" }), _jsx(KeyboardShortcutHint, { shortcut: "esc", action: "cancel" })] }) });
+        $[29] = t12;
+    }
+    else {
+        t12 = $[29];
+    }
+    let t13;
+    if ($[30] !== handleKeyDown || $[31] !== t11) {
+        t13 = _jsx(Pane, { children: _jsxs(Box, { flexDirection: "column", gap: 1, tabIndex: 0, autoFocus: true, onKeyDown: handleKeyDown, children: [t7, t11, t12] }) });
+        $[30] = handleKeyDown;
+        $[31] = t11;
+        $[32] = t13;
+    }
+    else {
+        t13 = $[32];
+    }
+    return t13;
+}
+function _temp2(c) {
+    return {
+        ...c,
+        copyFullResponse: true
+    };
+}
+function _temp(block, index) {
+    const blockLines = countCharInString(block.code, "\n") + 1;
+    return {
+        label: truncateLine(block.code, 60),
+        value: index,
+        description: [block.lang, blockLines > 1 ? `${blockLines} lines` : undefined].filter(Boolean).join(", ") || undefined
+    };
+}
+export const call = async (onDone, context, args) => {
+    const texts = collectRecentAssistantTexts(context.messages);
+    if (texts.length === 0) {
+        onDone('No assistant message to copy');
+        return null;
+    }
+    // /copy N reaches back N-1 messages (1 = latest, 2 = second-to-latest, ...)
+    let age = 0;
+    const arg = args?.trim();
+    if (arg) {
+        const n = Number(arg);
+        if (!Number.isInteger(n) || n < 1) {
+            onDone(`Usage: /copy [N] where N is 1 (latest), 2, 3, \u2026 Got: ${arg}`);
+            return null;
+        }
+        if (n > texts.length) {
+            onDone(`Only ${texts.length} assistant ${texts.length === 1 ? 'message' : 'messages'} available to copy`);
+            return null;
+        }
+        age = n - 1;
+    }
+    const text = texts[age];
+    const codeBlocks = extractCodeBlocks(text);
+    const config = getGlobalConfig();
+    if (codeBlocks.length === 0 || config.copyFullResponse) {
+        logEvent('thaddeus_copy', {
+            always: config.copyFullResponse,
+            block_count: codeBlocks.length,
+            message_age: age
+        });
+        const result = await copyOrWriteToFile(text, RESPONSE_FILENAME);
+        onDone(result);
+        return null;
+    }
+    return _jsx(CopyPicker, { fullText: text, codeBlocks: codeBlocks, messageAge: age, onDone: onDone });
+};