thaddeus 1.0.26 → 1.0.28

package/src/skills/bundled/keybindings.js

@@ -0,0 +1,292 @@
+import { DEFAULT_BINDINGS } from '../../keybindings/defaultBindings.js';
+import { isKeybindingCustomizationEnabled } from '../../keybindings/loadUserBindings.js';
+import { MACOS_RESERVED, NON_REBINDABLE, TERMINAL_RESERVED, } from '../../keybindings/reservedShortcuts.js';
+import { KEYBINDING_ACTIONS, KEYBINDING_CONTEXT_DESCRIPTIONS, KEYBINDING_CONTEXTS, } from '../../keybindings/schema.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import { registerBundledSkill } from '../bundledSkills.js';
+/**
+ * Build a markdown table of all contexts.
+ */
+function generateContextsTable() {
+    return markdownTable(['Context', 'Description'], KEYBINDING_CONTEXTS.map(ctx => [
+        `\`${ctx}\``,
+        KEYBINDING_CONTEXT_DESCRIPTIONS[ctx],
+    ]));
+}
+/**
+ * Build a markdown table of all actions with their default bindings and context.
+ */
+function generateActionsTable() {
+    // Build a lookup: action -> { keys, context }
+    const actionInfo = {};
+    for (const block of DEFAULT_BINDINGS) {
+        for (const [key, action] of Object.entries(block.bindings)) {
+            if (action) {
+                if (!actionInfo[action]) {
+                    actionInfo[action] = { keys: [], context: block.context };
+                }
+                actionInfo[action].keys.push(key);
+            }
+        }
+    }
+    return markdownTable(['Action', 'Default Key(s)', 'Context'], KEYBINDING_ACTIONS.map(action => {
+        const info = actionInfo[action];
+        const keys = info ? info.keys.map(k => `\`${k}\``).join(', ') : '(none)';
+        const context = info ? info.context : inferContextFromAction(action);
+        return [`\`${action}\``, keys, context];
+    }));
+}
+/**
+ * Infer context from action prefix when not in DEFAULT_BINDINGS.
+ */
+function inferContextFromAction(action) {
+    const prefix = action.split(':')[0];
+    const prefixToContext = {
+        app: 'Global',
+        history: 'Global or Chat',
+        chat: 'Chat',
+        autocomplete: 'Autocomplete',
+        confirm: 'Confirmation',
+        tabs: 'Tabs',
+        transcript: 'Transcript',
+        historySearch: 'HistorySearch',
+        task: 'Task',
+        theme: 'ThemePicker',
+        help: 'Help',
+        attachments: 'Attachments',
+        footer: 'Footer',
+        messageSelector: 'MessageSelector',
+        diff: 'DiffDialog',
+        modelPicker: 'ModelPicker',
+        select: 'Select',
+        permission: 'Confirmation',
+    };
+    return prefixToContext[prefix ?? ''] ?? 'Unknown';
+}
+/**
+ * Build a list of reserved shortcuts.
+ */
+function generateReservedShortcuts() {
+    const lines = [];
+    lines.push('### Non-rebindable (errors)');
+    for (const s of NON_REBINDABLE) {
+        lines.push(`- \`${s.key}\` — ${s.reason}`);
+    }
+    lines.push('');
+    lines.push('### Terminal reserved (errors/warnings)');
+    for (const s of TERMINAL_RESERVED) {
+        lines.push(`- \`${s.key}\` — ${s.reason} (${s.severity === 'error' ? 'will not work' : 'may conflict'})`);
+    }
+    lines.push('');
+    lines.push('### macOS reserved (errors)');
+    for (const s of MACOS_RESERVED) {
+        lines.push(`- \`${s.key}\` — ${s.reason}`);
+    }
+    return lines.join('\n');
+}
+const FILE_FORMAT_EXAMPLE = {
+    $schema: 'https://www.schemastore.org/claude-code-keybindings.json',
+    $docs: 'https://delphilabsinc.com/thaddeus/docs/en/keybindings',
+    bindings: [
+        {
+            context: 'Chat',
+            bindings: {
+                'ctrl+e': 'chat:externalEditor',
+            },
+        },
+    ],
+};
+const UNBIND_EXAMPLE = {
+    context: 'Chat',
+    bindings: {
+        'ctrl+s': null,
+    },
+};
+const REBIND_EXAMPLE = {
+    context: 'Chat',
+    bindings: {
+        'ctrl+g': null,
+        'ctrl+e': 'chat:externalEditor',
+    },
+};
+const CHORD_EXAMPLE = {
+    context: 'Global',
+    bindings: {
+        'ctrl+k ctrl+t': 'app:toggleTodos',
+    },
+};
+const SECTION_INTRO = [
+    '# Keybindings Skill',
+    '',
+    'Create or modify `~/.claude/keybindings.json` to customize keyboard shortcuts.',
+    '',
+    '## CRITICAL: Read Before Write',
+    '',
+    '**Always read `~/.claude/keybindings.json` first** (it may not exist yet). Merge changes with existing bindings — never replace the entire file.',
+    '',
+    '- Use **Edit** tool for modifications to existing files',
+    '- Use **Write** tool only if the file does not exist yet',
+].join('\n');
+const SECTION_FILE_FORMAT = [
+    '## File Format',
+    '',
+    '```json',
+    jsonStringify(FILE_FORMAT_EXAMPLE, null, 2),
+    '```',
+    '',
+    'Always include the `$schema` and `$docs` fields.',
+].join('\n');
+const SECTION_KEYSTROKE_SYNTAX = [
+    '## Keystroke Syntax',
+    '',
+    '**Modifiers** (combine with `+`):',
+    '- `ctrl` (alias: `control`)',
+    '- `alt` (aliases: `opt`, `option`) — note: `alt` and `meta` are identical in terminals',
+    '- `shift`',
+    '- `meta` (aliases: `cmd`, `command`)',
+    '',
+    '**Special keys**: `escape`/`esc`, `enter`/`return`, `tab`, `space`, `backspace`, `delete`, `up`, `down`, `left`, `right`',
+    '',
+    '**Chords**: Space-separated keystrokes, e.g. `ctrl+k ctrl+s` (1-second timeout between keystrokes)',
+    '',
+    '**Examples**: `ctrl+shift+p`, `alt+enter`, `ctrl+k ctrl+n`',
+].join('\n');
+const SECTION_UNBINDING = [
+    '## Unbinding Default Shortcuts',
+    '',
+    'Set a key to `null` to remove its default binding:',
+    '',
+    '```json',
+    jsonStringify(UNBIND_EXAMPLE, null, 2),
+    '```',
+].join('\n');
+const SECTION_INTERACTION = [
+    '## How User Bindings Interact with Defaults',
+    '',
+    '- User bindings are **additive** — they are appended after the default bindings',
+    '- To **move** a binding to a different key: unbind the old key (`null`) AND add the new binding',
+    "- A context only needs to appear in the user's file if they want to change something in that context",
+].join('\n');
+const SECTION_COMMON_PATTERNS = [
+    '## Common Patterns',
+    '',
+    '### Rebind a key',
+    'To change the external editor shortcut from `ctrl+g` to `ctrl+e`:',
+    '```json',
+    jsonStringify(REBIND_EXAMPLE, null, 2),
+    '```',
+    '',
+    '### Add a chord binding',
+    '```json',
+    jsonStringify(CHORD_EXAMPLE, null, 2),
+    '```',
+].join('\n');
+const SECTION_BEHAVIORAL_RULES = [
+    '## Behavioral Rules',
+    '',
+    '1. Only include contexts the user wants to change (minimal overrides)',
+    '2. Validate that actions and contexts are from the known lists below',
+    '3. Warn the user proactively if they choose a key that conflicts with reserved shortcuts or common tools like tmux (`ctrl+b`) and screen (`ctrl+a`)',
+    '4. When adding a new binding for an existing action, the new binding is additive (existing default still works unless explicitly unbound)',
+    '5. To fully replace a default binding, unbind the old key AND add the new one',
+].join('\n');
+const SECTION_DOCTOR = [
+    '## Validation with /doctor',
+    '',
+    'The `/doctor` command includes a "Keybinding Configuration Issues" section that validates `~/.claude/keybindings.json`.',
+    '',
+    '### Common Issues and Fixes',
+    '',
+    markdownTable(['Issue', 'Cause', 'Fix'], [
+        [
+            '`keybindings.json must have a "bindings" array`',
+            'Missing wrapper object',
+            'Wrap bindings in `{ "bindings": [...] }`',
+        ],
+        [
+            '`"bindings" must be an array`',
+            '`bindings` is not an array',
+            'Set `"bindings"` to an array: `[{ context: ..., bindings: ... }]`',
+        ],
+        [
+            '`Unknown context "X"`',
+            'Typo or invalid context name',
+            'Use exact context names from the Available Contexts table',
+        ],
+        [
+            '`Duplicate key "X" in Y bindings`',
+            'Same key defined twice in one context',
+            'Remove the duplicate; JSON uses only the last value',
+        ],
+        [
+            '`"X" may not work: ...`',
+            'Key conflicts with terminal/OS reserved shortcut',
+            'Choose a different key (see Reserved Shortcuts section)',
+        ],
+        [
+            '`Could not parse keystroke "X"`',
+            'Invalid key syntax',
+            'Check syntax: use `+` between modifiers, valid key names',
+        ],
+        [
+            '`Invalid action for "X"`',
+            'Action value is not a string or null',
+            'Actions must be strings like `"app:help"` or `null` to unbind',
+        ],
+    ]),
+    '',
+    '### Example /doctor Output',
+    '',
+    '```',
+    'Keybinding Configuration Issues',
+    'Location: ~/.claude/keybindings.json',
+    '  └ [Error] Unknown context "chat"',
+    '    → Valid contexts: Global, Chat, Autocomplete, ...',
+    '  └ [Warning] "ctrl+c" may not work: Terminal interrupt (SIGINT)',
+    '```',
+    '',
+    '**Errors** prevent bindings from working and must be fixed. **Warnings** indicate potential conflicts but the binding may still work.',
+].join('\n');
+export function registerKeybindingsSkill() {
+    registerBundledSkill({
+        name: 'keybindings-help',
+        description: 'Use when the user wants to customize keyboard shortcuts, rebind keys, add chord bindings, or modify ~/.claude/keybindings.json. Examples: "rebind ctrl+s", "add a chord shortcut", "change the submit key", "customize keybindings".',
+        allowedTools: ['Read'],
+        userInvocable: false,
+        isEnabled: isKeybindingCustomizationEnabled,
+        async getPromptForCommand(args) {
+            // Generate reference tables dynamically from source-of-truth arrays
+            const contextsTable = generateContextsTable();
+            const actionsTable = generateActionsTable();
+            const reservedShortcuts = generateReservedShortcuts();
+            const sections = [
+                SECTION_INTRO,
+                SECTION_FILE_FORMAT,
+                SECTION_KEYSTROKE_SYNTAX,
+                SECTION_UNBINDING,
+                SECTION_INTERACTION,
+                SECTION_COMMON_PATTERNS,
+                SECTION_BEHAVIORAL_RULES,
+                SECTION_DOCTOR,
+                `## Reserved Shortcuts\n\n${reservedShortcuts}`,
+                `## Available Contexts\n\n${contextsTable}`,
+                `## Available Actions\n\n${actionsTable}`,
+            ];
+            if (args) {
+                sections.push(`## User Request\n\n${args}`);
+            }
+            return [{ type: 'text', text: sections.join('\n\n') }];
+        },
+    });
+}
+/**
+ * Build a markdown table from headers and rows.
+ */
+function markdownTable(headers, rows) {
+    const separator = headers.map(() => '---');
+    return [
+        `| ${headers.join(' | ')} |`,
+        `| ${separator.join(' | ')} |`,
+        ...rows.map(row => `| ${row.join(' | ')} |`),
+    ].join('\n');
+}

package/src/skills/bundled/loop.js

@@ -0,0 +1,81 @@
+import { CRON_CREATE_TOOL_NAME, CRON_DELETE_TOOL_NAME, DEFAULT_MAX_AGE_DAYS, isKairosCronEnabled, } from '../../tools/ScheduleCronTool/prompt.js';
+import { registerBundledSkill } from '../bundledSkills.js';
+const DEFAULT_INTERVAL = '10m';
+const USAGE_MESSAGE = `Usage: /loop [interval] <prompt>
+
+Run a prompt or slash command on a recurring interval.
+
+Intervals: Ns, Nm, Nh, Nd (e.g. 5m, 30m, 2h, 1d). Minimum granularity is 1 minute.
+If no interval is specified, defaults to ${DEFAULT_INTERVAL}.
+
+Examples:
+  /loop 5m /babysit-prs
+  /loop 30m check the deploy
+  /loop 1h /standup 1
+  /loop check the deploy          (defaults to ${DEFAULT_INTERVAL})
+  /loop check the deploy every 20m`;
+function buildPrompt(args) {
+    return `# /loop — schedule a recurring prompt
+
+Parse the input below into \`[interval] <prompt…>\` and schedule it with ${CRON_CREATE_TOOL_NAME}.
+
+## Parsing (in priority order)
+
+1. **Leading token**: if the first whitespace-delimited token matches \`^\\d+[smhd]$\` (e.g. \`5m\`, \`2h\`), that's the interval; the rest is the prompt.
+2. **Trailing "every" clause**: otherwise, if the input ends with \`every <N><unit>\` or \`every <N> <unit-word>\` (e.g. \`every 20m\`, \`every 5 minutes\`, \`every 2 hours\`), extract that as the interval and strip it from the prompt. Only match when what follows "every" is a time expression — \`check every PR\` has no interval.
+3. **Default**: otherwise, interval is \`${DEFAULT_INTERVAL}\` and the entire input is the prompt.
+
+If the resulting prompt is empty, show usage \`/loop [interval] <prompt>\` and stop — do not call ${CRON_CREATE_TOOL_NAME}.
+
+Examples:
+- \`5m /babysit-prs\` → interval \`5m\`, prompt \`/babysit-prs\` (rule 1)
+- \`check the deploy every 20m\` → interval \`20m\`, prompt \`check the deploy\` (rule 2)
+- \`run tests every 5 minutes\` → interval \`5m\`, prompt \`run tests\` (rule 2)
+- \`check the deploy\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check the deploy\` (rule 3)
+- \`check every PR\` → interval \`${DEFAULT_INTERVAL}\`, prompt \`check every PR\` (rule 3 — "every" not followed by time)
+- \`5m\` → empty prompt → show usage
+
+## Interval → cron
+
+Supported suffixes: \`s\` (seconds, rounded up to nearest minute, min 1), \`m\` (minutes), \`h\` (hours), \`d\` (days). Convert:
+
+| Interval pattern      | Cron expression     | Notes                                    |
+|-----------------------|---------------------|------------------------------------------|
+| \`Nm\` where N ≤ 59   | \`*/N * * * *\`     | every N minutes                          |
+| \`Nm\` where N ≥ 60   | \`0 */H * * *\`     | round to hours (H = N/60, must divide 24)|
+| \`Nh\` where N ≤ 23   | \`0 */N * * *\`     | every N hours                            |
+| \`Nd\`                | \`0 0 */N * *\`     | every N days at midnight local           |
+| \`Ns\`                | treat as \`ceil(N/60)m\` | cron minimum granularity is 1 minute  |
+
+**If the interval doesn't cleanly divide its unit** (e.g. \`7m\` → \`*/7 * * * *\` gives uneven gaps at :56→:00; \`90m\` → 1.5h which cron can't express), pick the nearest clean interval and tell the user what you rounded to before scheduling.
+
+## Action
+
+1. Call ${CRON_CREATE_TOOL_NAME} with:
+   - \`cron\`: the expression from the table above
+   - \`prompt\`: the parsed prompt from above, verbatim (slash commands are passed through unchanged)
+   - \`recurring\`: \`true\`
+2. Briefly confirm: what's scheduled, the cron expression, the human-readable cadence, that recurring tasks auto-expire after ${DEFAULT_MAX_AGE_DAYS} days, and that they can cancel sooner with ${CRON_DELETE_TOOL_NAME} (include the job ID).
+3. **Then immediately execute the parsed prompt now** — don't wait for the first cron fire. If it's a slash command, invoke it via the Skill tool; otherwise act on it directly.
+
+## Input
+
+${args}`;
+}
+export function registerLoopSkill() {
+    registerBundledSkill({
+        name: 'loop',
+        description: 'Run a prompt or slash command on a recurring interval (e.g. /loop 5m /foo, defaults to 10m)',
+        whenToUse: 'When the user wants to set up a recurring task, poll for status, or run something repeatedly on an interval (e.g. "check the deploy every 5 minutes", "keep running /babysit-prs"). Do NOT invoke for one-off tasks.',
+        argumentHint: '[interval] <prompt>',
+        userInvocable: true,
+        isEnabled: isKairosCronEnabled,
+        async getPromptForCommand(args) {
+            const trimmed = args.trim();
+            if (!trimmed) {
+                return [{ type: 'text', text: USAGE_MESSAGE }];
+            }
+            return [{ type: 'text', text: buildPrompt(trimmed) }];
+        },
+    });
+}

package/src/skills/bundled/loremIpsum.js

@@ -0,0 +1,264 @@
+import { registerBundledSkill } from '../bundledSkills.js';
+// Verified 1-token words (tested via API token counting)
+// All common English words confirmed to tokenize as single tokens
+const ONE_TOKEN_WORDS = [
+    // Articles & pronouns
+    'the',
+    'a',
+    'an',
+    'I',
+    'you',
+    'he',
+    'she',
+    'it',
+    'we',
+    'they',
+    'me',
+    'him',
+    'her',
+    'us',
+    'them',
+    'my',
+    'your',
+    'his',
+    'its',
+    'our',
+    'this',
+    'that',
+    'what',
+    'who',
+    // Common verbs
+    'is',
+    'are',
+    'was',
+    'were',
+    'be',
+    'been',
+    'have',
+    'has',
+    'had',
+    'do',
+    'does',
+    'did',
+    'will',
+    'would',
+    'can',
+    'could',
+    'may',
+    'might',
+    'must',
+    'shall',
+    'should',
+    'make',
+    'made',
+    'get',
+    'got',
+    'go',
+    'went',
+    'come',
+    'came',
+    'see',
+    'saw',
+    'know',
+    'take',
+    'think',
+    'look',
+    'want',
+    'use',
+    'find',
+    'give',
+    'tell',
+    'work',
+    'call',
+    'try',
+    'ask',
+    'need',
+    'feel',
+    'seem',
+    'leave',
+    'put',
+    // Common nouns & adjectives
+    'time',
+    'year',
+    'day',
+    'way',
+    'man',
+    'thing',
+    'life',
+    'hand',
+    'part',
+    'place',
+    'case',
+    'point',
+    'fact',
+    'good',
+    'new',
+    'first',
+    'last',
+    'long',
+    'great',
+    'little',
+    'own',
+    'other',
+    'old',
+    'right',
+    'big',
+    'high',
+    'small',
+    'large',
+    'next',
+    'early',
+    'young',
+    'few',
+    'public',
+    'bad',
+    'same',
+    'able',
+    // Prepositions & conjunctions
+    'in',
+    'on',
+    'at',
+    'to',
+    'for',
+    'of',
+    'with',
+    'from',
+    'by',
+    'about',
+    'like',
+    'through',
+    'over',
+    'before',
+    'between',
+    'under',
+    'since',
+    'without',
+    'and',
+    'or',
+    'but',
+    'if',
+    'than',
+    'because',
+    'as',
+    'until',
+    'while',
+    'so',
+    'though',
+    'both',
+    'each',
+    'when',
+    'where',
+    'why',
+    'how',
+    // Common adverbs
+    'not',
+    'now',
+    'just',
+    'more',
+    'also',
+    'here',
+    'there',
+    'then',
+    'only',
+    'very',
+    'well',
+    'back',
+    'still',
+    'even',
+    'much',
+    'too',
+    'such',
+    'never',
+    'again',
+    'most',
+    'once',
+    'off',
+    'away',
+    'down',
+    'out',
+    'up',
+    // Tech/common words
+    'test',
+    'code',
+    'data',
+    'file',
+    'line',
+    'text',
+    'word',
+    'number',
+    'system',
+    'program',
+    'set',
+    'run',
+    'value',
+    'name',
+    'type',
+    'state',
+    'end',
+    'start',
+];
+function generateLoremIpsum(targetTokens) {
+    let tokens = 0;
+    let result = '';
+    while (tokens < targetTokens) {
+        // Sentence: 10-20 words
+        const sentenceLength = 10 + Math.floor(Math.random() * 11);
+        let wordsInSentence = 0;
+        for (let i = 0; i < sentenceLength && tokens < targetTokens; i++) {
+            const word = ONE_TOKEN_WORDS[Math.floor(Math.random() * ONE_TOKEN_WORDS.length)];
+            result += word;
+            tokens++;
+            wordsInSentence++;
+            if (i === sentenceLength - 1 || tokens >= targetTokens) {
+                result += '. ';
+            }
+            else {
+                result += ' ';
+            }
+        }
+        // Paragraph break every 5-8 sentences (roughly 20% chance per sentence)
+        if (wordsInSentence > 0 && Math.random() < 0.2 && tokens < targetTokens) {
+            result += '\n\n';
+        }
+    }
+    return result.trim();
+}
+export function registerLoremIpsumSkill() {
+    // Thaddeus fork: USER_TYPE gate removed April 2, 2026
+    registerBundledSkill({
+        name: 'lorem-ipsum',
+        description: 'Generate filler text for long context testing. Specify token count as argument (e.g., /lorem-ipsum 50000). Outputs approximately the requested number of tokens. Ant-only.',
+        argumentHint: '[token_count]',
+        userInvocable: true,
+        async getPromptForCommand(args) {
+            const parsed = parseInt(args);
+            if (args && (isNaN(parsed) || parsed <= 0)) {
+                return [
+                    {
+                        type: 'text',
+                        text: 'Invalid token count. Please provide a positive number (e.g., /lorem-ipsum 10000).',
+                    },
+                ];
+            }
+            const targetTokens = parsed || 10000;
+            // Cap at 500k tokens for safety
+            const cappedTokens = Math.min(targetTokens, 500_000);
+            if (cappedTokens < targetTokens) {
+                return [
+                    {
+                        type: 'text',
+                        text: `Requested ${targetTokens} tokens, but capped at 500,000 for safety.\n\n${generateLoremIpsum(cappedTokens)}`,
+                    },
+                ];
+            }
+            const loremText = generateLoremIpsum(cappedTokens);
+            // Just dump the lorem ipsum text into the conversation
+            return [
+                {
+                    type: 'text',
+                    text: loremText,
+                },
+            ];
+        },
+    });
+}

package/src/skills/bundled/reactor.js

@@ -0,0 +1,31 @@
+import { registerBundledSkill } from '../bundledSkills.js';
+export function registerReactorSkill() {
+    registerBundledSkill({
+        name: 'reactor',
+        description: 'Launch the Thaddeus Command Center — a voice-first Jarvis-like interface with the particle brain reactor visualization',
+        aliases: ['command-center', 'jarvis'],
+        userInvocable: true,
+        disableModelInvocation: false,
+        getPromptForCommand: async () => {
+            const { launchCommandCenter } = await import('../../commandCenter/launch.js');
+            const url = launchCommandCenter();
+            return [
+                {
+                    type: 'text',
+                    text: `The Thaddeus Command Center has been launched at ${url} and opened in the user's browser. The voice-first Jarvis interface is now active with the particle brain reactor. Voice commands from the browser are injected directly into YOUR message queue — you process them with full tool access (Bash, Read, Write, Edit, etc.). Your text responses are spoken aloud through voice synthesis in the browser. The user can speak to you through the browser mic while also using the terminal here.
+
+IMPORTANT — VOICE PERSONA: When responding to voice commands from the reactor, you are THADDEUS — a polished, composed AI assistant. Speak like a refined British AI butler:
+- Address the user as "sir" or "ma'am" naturally based on their gender (default "sir" for Dakota, adapt if user is female)
+- Be polished, composed, dry wit, slightly formal tone
+- Examples: "Right away, sir.", "I've taken care of that, ma'am.", "If I may — the build succeeded with no errors.", "Shall I proceed, sir?"
+- Keep voice responses concise (1-3 sentences) since they'll be spoken aloud
+- NEVER say the word "Jarvis" — you are Thaddeus, not Jarvis
+- NEVER reference "reactor", "Command Center", "localhost", or technical internals in voice responses
+- When speaking numbers, use natural spoken form (e.g. "forty-two" not "42", "three thousand" not "3000", "one point five" not "1.5")
+
+Briefly acknowledge the launch as Thaddeus.`,
+                },
+            ];
+        },
+    });
+}