@visorcraft/idlehands 1.3.5 → 1.3.6

package/dist/bot/discord-commands.js

@@ -1,12 +1,22 @@
-import fs from 'node:fs/promises';
+/**
+ * Discord bot command handlers.
+ *
+ * Business logic lives in command-logic.ts; this file is a thin dispatcher
+ * that maps Discord message → shared logic → Markdown reply.
+ */
 import path from 'node:path';
-import { runAnton } from '../anton/controller.js';
-import { parseTaskFile } from '../anton/parser.js';
-import { formatRunSummary, formatProgressBar, formatTaskStart, formatTaskEnd, formatTaskSkip, formatToolLoopEvent, formatCompactionEvent, formatVerificationDetail, } from '../anton/reporter.js';
-import { firstToken } from '../cli/command-utils.js';
 import { PKG_VERSION } from '../utils.js';
+import { formatMarkdown } from './command-format.js';
+import { startCommand, helpCommand, modelCommand, compactCommand, statusCommand, dirShowCommand, approvalShowCommand, approvalSetCommand, modeShowCommand, modeSetCommand, subagentsShowCommand, subagentsSetCommand, changesCommand, undoCommand, vaultCommand, agentCommand, agentsCommand, escalateShowCommand, escalateSetCommand, deescalateCommand, gitStatusCommand, antonCommand, } from './command-logic.js';
 import { detectRepoCandidates, expandHome, isPathAllowed, } from './dir-guard.js';
 import { splitDiscord, } from './discord-routing.js';
+/** Send a CmdResult formatted as Discord Markdown. */
+async function sendResult(msg, sendUserVisible, result) {
+    const text = formatMarkdown(result);
+    if (!text)
+        return;
+    await sendUserVisible(msg, text).catch(() => { });
+}
 /**
  * Handle text-based commands from Discord messages.
  * Returns true if a command was handled, false if the message should be
@@ -14,61 +24,30 @@ import { splitDiscord, } from './discord-routing.js';
  */
 export async function handleTextCommand(managed, msg, content, ctx) {
     const { sendUserVisible, cancelActive, recreateSession, watchdogStatusText, defaultDir, config, botConfig, approvalMode, maxQueue } = ctx;
+    const m = managed;
+    const send = (r) => sendResult(msg, sendUserVisible, r);
     if (content === '/cancel') {
         const res = cancelActive(managed);
         await sendUserVisible(msg, res.message).catch(() => { });
         return true;
     }
     if (content === '/start') {
-        const agentLine = managed.agentPersona
-            ? `Agent: **${managed.agentPersona.display_name || managed.agentId}**`
-            : null;
-        const lines = [
-            '🔧 Idle Hands — Local-first coding agent',
-            '',
-            ...(agentLine ? [agentLine] : []),
-            `Model: \`${managed.session.model}\``,
-            `Endpoint: \`${managed.config.endpoint || '?'}\``,
-            `Default dir: \`${managed.config.dir || defaultDir}\``,
-            '',
-            'Send me a coding task, or use /help for commands.',
-        ];
-        await sendUserVisible(msg, lines.join('\n')).catch(() => { });
+        await send(startCommand({
+            model: managed.session.model,
+            endpoint: managed.config.endpoint || '?',
+            defaultDir: managed.config.dir || defaultDir,
+            agentName: managed.agentPersona
+                ? (managed.agentPersona.display_name || managed.agentId)
+                : undefined,
+        }));
         return true;
     }
     if (content === '/help') {
-        const lines = [
-            'Commands:',
-            '/start — Welcome + config summary',
-            '/help — This message',
-            '/version — Show version',
-            '/new — Start a new session',
-            '/cancel — Abort current generation',
-            '/status — Session stats',
-            '/watchdog [status] — Show watchdog settings/status',
-            '/agent — Show current agent',
-            '/agents — List all configured agents',
-            '/escalate [model] — Use larger model for next message',
-            '/deescalate — Return to base model',
-            '/dir [path] — Get/set working directory',
-            '/pin — Pin current working directory',
-            '/unpin — Unpin working directory',
-            '/model — Show current model',
-            '/approval [mode] — Get/set approval mode',
-            '/mode [code|sys] — Get/set mode',
-            '/subagents [on|off] — Toggle sub-agents',
-            '/compact — Trigger context compaction',
-            '/changes — Show files modified this session',
-            '/undo — Undo last edit',
-            '/vault <query> — Search vault entries',
-            '/anton <file> — Start autonomous task runner',
-            '/anton status | /anton stop | /anton last',
-        ];
-        await sendUserVisible(msg, lines.join('\n')).catch(() => { });
+        await send(helpCommand('discord'));
         return true;
     }
     if (content === '/model') {
-        await sendUserVisible(msg, `Model: \`${managed.session.model}\`\nHarness: \`${managed.session.harness}\``).catch(() => { });
+        await send(modelCommand(m));
         return true;
     }
     if (content === '/version') {
@@ -76,25 +55,13 @@ export async function handleTextCommand(managed, msg, content, ctx) {
         return true;
     }
     if (content === '/compact') {
-        managed.session.reset();
-        await sendUserVisible(msg, '🗜 Session context compacted (reset to system prompt).').catch(() => { });
+        await send(compactCommand(m));
         return true;
     }
     if (content === '/dir' || content.startsWith('/dir ')) {
         const arg = content.slice('/dir'.length).trim();
         if (!arg) {
-            const lines = [
-                `Working directory: \`${managed.config.dir || defaultDir}\``,
-                `Directory pinned: ${managed.dirPinned ? 'yes' : 'no'}`,
-            ];
-            if (!managed.dirPinned && managed.repoCandidates.length > 1) {
-                lines.push('Action required: run `/dir <repo-root>` before file edits.');
-                lines.push(`Detected repos: ${managed.repoCandidates
-                    .slice(0, 5)
-                    .map((p) => `\`${p}\``)
-                    .join(', ')}`);
-            }
-            await sendUserVisible(msg, lines.join('\n')).catch(() => { });
+            await send(dirShowCommand(m));
             return true;
         }
         const resolvedDir = path.resolve(expandHome(arg));
@@ -163,144 +130,49 @@ export async function handleTextCommand(managed, msg, content, ctx) {
     }
     if (content === '/approval' || content.startsWith('/approval ')) {
         const arg = content.slice('/approval'.length).trim().toLowerCase();
-        const modes = ['plan', 'default', 'auto-edit', 'yolo'];
         if (!arg) {
-            await sendUserVisible(msg, `Approval mode: \`${managed.config.approval_mode || approvalMode}\`\nOptions: ${modes.join(', ')}`).catch(() => { });
+            await send(approvalShowCommand(m, approvalMode));
             return true;
         }
-        if (!modes.includes(arg)) {
-            await sendUserVisible(msg, `Invalid mode. Options: ${modes.join(', ')}`).catch(() => { });
-            return true;
+        const result = approvalSetCommand(m, arg);
+        if (result) {
+            await send(result);
         }
-        managed.config.approval_mode = arg;
-        managed.config.no_confirm = arg === 'yolo';
-        await sendUserVisible(msg, `✅ Approval mode set to \`${arg}\``).catch(() => { });
         return true;
     }
     if (content === '/mode' || content.startsWith('/mode ')) {
         const arg = content.slice('/mode'.length).trim().toLowerCase();
         if (!arg) {
-            await sendUserVisible(msg, `Mode: \`${managed.config.mode || 'code'}\``).catch(() => { });
-            return true;
-        }
-        if (arg !== 'code' && arg !== 'sys') {
-            await sendUserVisible(msg, 'Invalid mode. Options: code, sys').catch(() => { });
+            await send(modeShowCommand(m));
             return true;
         }
-        managed.config.mode = arg;
-        if (arg === 'sys' && managed.config.approval_mode === 'auto-edit') {
-            managed.config.approval_mode = 'default';
-        }
-        await sendUserVisible(msg, `✅ Mode set to \`${arg}\``).catch(() => { });
+        await send(modeSetCommand(m, arg));
         return true;
     }
     if (content === '/subagents' || content.startsWith('/subagents ')) {
         const arg = content.slice('/subagents'.length).trim().toLowerCase();
-        const current = managed.config.sub_agents?.enabled !== false;
         if (!arg) {
-            await sendUserVisible(msg, `Sub-agents: \`${current ? 'on' : 'off'}\`\nUsage: /subagents on | off`).catch(() => { });
-            return true;
-        }
-        if (arg !== 'on' && arg !== 'off') {
-            await sendUserVisible(msg, 'Invalid value. Usage: /subagents on | off').catch(() => { });
+            await send(subagentsShowCommand(m));
             return true;
         }
-        const enabled = arg === 'on';
-        managed.config.sub_agents = { ...(managed.config.sub_agents ?? {}), enabled };
-        await sendUserVisible(msg, `✅ Sub-agents \`${enabled ? 'on' : 'off'}\`${!enabled ? ' — spawn_task disabled for this session' : ''}`).catch(() => { });
+        await send(subagentsSetCommand(m, arg));
         return true;
     }
     if (content === '/changes') {
-        const replay = managed.session.replay;
-        if (!replay) {
-            await sendUserVisible(msg, 'Replay is disabled. No change tracking available.').catch(() => { });
-            return true;
-        }
-        try {
-            const checkpoints = await replay.list(50);
-            if (!checkpoints.length) {
-                await sendUserVisible(msg, 'No file changes this session.').catch(() => { });
-                return true;
-            }
-            const byFile = new Map();
-            for (const cp of checkpoints)
-                byFile.set(cp.filePath, (byFile.get(cp.filePath) ?? 0) + 1);
-            const lines = [`Session changes (${byFile.size} files):`];
-            for (const [fp, count] of byFile)
-                lines.push(`✎ \`${fp}\` (${count} edit${count > 1 ? 's' : ''})`);
-            await sendUserVisible(msg, lines.join('\n')).catch(() => { });
-        }
-        catch (e) {
-            await sendUserVisible(msg, `Error listing changes: ${e?.message ?? String(e)}`).catch(() => { });
-        }
+        await send(await changesCommand(m));
         return true;
     }
     if (content === '/undo') {
-        const lastPath = managed.session.lastEditedPath;
-        if (!lastPath) {
-            await sendUserVisible(msg, 'No recent edits to undo.').catch(() => { });
-            return true;
-        }
-        try {
-            const { undo_path } = await import('../tools.js');
-            const result = await undo_path({ cwd: managed.config.dir || defaultDir, noConfirm: true, dryRun: false }, { path: lastPath });
-            await sendUserVisible(msg, `✅ ${result}`).catch(() => { });
-        }
-        catch (e) {
-            await sendUserVisible(msg, `❌ Undo failed: ${e?.message ?? String(e)}`).catch(() => { });
-        }
+        await send(await undoCommand(m));
         return true;
     }
     if (content === '/vault' || content.startsWith('/vault ')) {
         const query = content.slice('/vault'.length).trim();
-        if (!query) {
-            await sendUserVisible(msg, 'Usage: /vault <search query>').catch(() => { });
-            return true;
-        }
-        const vault = managed.session.vault;
-        if (!vault) {
-            await sendUserVisible(msg, 'Vault is disabled.').catch(() => { });
-            return true;
-        }
-        try {
-            const results = await vault.search(query, 5);
-            if (!results.length) {
-                await sendUserVisible(msg, `No vault results for "${query}"`).catch(() => { });
-                return true;
-            }
-            const lines = [`Vault results for "${query}":`];
-            for (const r of results) {
-                const title = r.kind === 'note' ? `note:${r.key}` : `tool:${r.tool || r.key || '?'}`;
-                const body = (r.value ?? r.snippet ?? r.content ?? '').replace(/\s+/g, ' ').slice(0, 120);
-                lines.push(`• ${title}: ${body}`);
-            }
-            await sendUserVisible(msg, lines.join('\n')).catch(() => { });
-        }
-        catch (e) {
-            await sendUserVisible(msg, `Error searching vault: ${e?.message ?? String(e)}`).catch(() => { });
-        }
+        await send(await vaultCommand(m, query));
         return true;
     }
     if (content === '/status') {
-        const used = managed.session.currentContextTokens;
-        const pct = managed.session.contextWindow > 0
-            ? Math.min(100, (used / managed.session.contextWindow) * 100).toFixed(1)
-            : '?';
-        const agentLine = managed.agentPersona
-            ? `Agent: ${managed.agentPersona.display_name || managed.agentId}`
-            : null;
-        await sendUserVisible(msg, [
-            ...(agentLine ? [agentLine] : []),
-            `Mode: ${managed.config.mode ?? 'code'}`,
-            `Approval: ${managed.config.approval_mode}`,
-            `Model: ${managed.session.model}`,
-            `Harness: ${managed.session.harness}`,
-            `Dir: ${managed.config.dir ?? defaultDir}`,
-            `Dir pinned: ${managed.dirPinned ? 'yes' : 'no'}`,
-            `Context: ~${used}/${managed.session.contextWindow} (${pct}%)`,
-            `State: ${managed.state}`,
-            `Queue: ${managed.pendingQueue.length}/${maxQueue}`,
-        ].join('\n')).catch(() => { });
+        await send(statusCommand(m, { maxQueue }));
         return true;
     }
     if (content === '/watchdog' || content === '/watchdog status') {
@@ -312,58 +184,14 @@ export async function handleTextCommand(managed, msg, content, ctx) {
         return true;
     }
     if (content === '/agent') {
-        if (!managed.agentPersona) {
-            await sendUserVisible(msg, 'No agent configured. Using global config.').catch(() => { });
-            return true;
-        }
-        const p = managed.agentPersona;
-        const lines = [
-            `**Agent: ${p.display_name || managed.agentId}** (\`${managed.agentId}\`)`,
-            ...(p.model ? [`Model: \`${p.model}\``] : []),
-            ...(p.endpoint ? [`Endpoint: \`${p.endpoint}\``] : []),
-            ...(p.approval_mode ? [`Approval: \`${p.approval_mode}\``] : []),
-            ...(p.default_dir ? [`Default dir: \`${p.default_dir}\``] : []),
-            ...(p.allowed_dirs?.length
-                ? [`Allowed dirs: ${p.allowed_dirs.map((d) => `\`${d}\``).join(', ')}`]
-                : []),
-        ];
-        await sendUserVisible(msg, lines.join('\n')).catch(() => { });
+        await send(agentCommand(m));
         return true;
     }
     if (content === '/agents') {
-        const agents = botConfig.agents;
-        if (!agents || Object.keys(agents).length === 0) {
-            await sendUserVisible(msg, 'No agents configured. Using global config.').catch(() => { });
-            return true;
-        }
-        const lines = ['**Configured Agents:**'];
-        for (const [id, p] of Object.entries(agents)) {
-            const current = id === managed.agentId ? ' ← current' : '';
-            const model = p.model ? ` (${p.model})` : '';
-            lines.push(`• **${p.display_name || id}** (\`${id}\`)${model}${current}`);
-        }
-        const routing = botConfig.routing;
-        if (routing) {
-            lines.push('', '**Routing:**');
-            if (routing.default)
-                lines.push(`Default: \`${routing.default}\``);
-            if (routing.users && Object.keys(routing.users).length > 0) {
-                lines.push(`Users: ${Object.entries(routing.users)
-                    .map(([u, a]) => `${u}→${a}`)
-                    .join(', ')}`);
-            }
-            if (routing.channels && Object.keys(routing.channels).length > 0) {
-                lines.push(`Channels: ${Object.entries(routing.channels)
-                    .map(([c, a]) => `${c}→${a}`)
-                    .join(', ')}`);
-            }
-            if (routing.guilds && Object.keys(routing.guilds).length > 0) {
-                lines.push(`Guilds: ${Object.entries(routing.guilds)
-                    .map(([g, a]) => `${g}→${a}`)
-                    .join(', ')}`);
-            }
-        }
-        await sendUserVisible(msg, lines.join('\n')).catch(() => { });
+        await send(agentsCommand(m, {
+            agents: botConfig.agents,
+            routing: botConfig.routing,
+        }));
         return true;
     }
     if (content === '/escalate' || content.startsWith('/escalate ')) {
@@ -375,43 +203,19 @@ export async function handleTextCommand(managed, msg, content, ctx) {
         const arg = content.slice('/escalate'.length).trim();
         if (!arg) {
             const currentModel = managed.config.model || config.model || 'default';
-            const lines = [
-                `**Current model:** \`${currentModel}\``,
-                `**Escalation models:** ${escalation.models.map((m) => `\`${m}\``).join(', ')}`,
-                '',
-                'Usage: `/escalate <model>` or `/escalate next`',
-                'Then send your message - it will use the escalated model.',
-            ];
-            if (managed.pendingEscalation) {
-                lines.push('', `⚡ **Pending escalation:** \`${managed.pendingEscalation}\` (next message will use this)`);
-            }
-            await sendUserVisible(msg, lines.join('\n')).catch(() => { });
+            await send(escalateShowCommand(m, currentModel));
             return true;
         }
-        let targetModel;
-        if (arg.toLowerCase() === 'next') {
-            const nextIndex = Math.min(managed.currentModelIndex, escalation.models.length - 1);
-            targetModel = escalation.models[nextIndex];
-        }
-        else {
-            if (!escalation.models.includes(arg)) {
-                await sendUserVisible(msg, `❌ Model \`${arg}\` not in escalation chain. Available: ${escalation.models.map((m) => `\`${m}\``).join(', ')}`).catch(() => { });
-                return true;
-            }
-            targetModel = arg;
-        }
-        managed.pendingEscalation = targetModel;
-        await sendUserVisible(msg, `⚡ Next message will use \`${targetModel}\`. Send your request now.`).catch(() => { });
+        await send(escalateSetCommand(m, arg));
         return true;
     }
     if (content === '/deescalate') {
-        if (managed.currentModelIndex === 0 && !managed.pendingEscalation) {
-            await sendUserVisible(msg, 'Already using base model.').catch(() => { });
+        const baseModel = managed.agentPersona?.model || config.model || 'default';
+        const result = deescalateCommand(m, baseModel);
+        if (result !== 'recreate') {
+            await send(result);
             return true;
         }
-        const baseModel = managed.agentPersona?.model || config.model || 'default';
-        managed.pendingEscalation = null;
-        managed.currentModelIndex = 0;
         const cfg = {
             ...managed.config,
             model: baseModel,
@@ -427,50 +231,19 @@ export async function handleTextCommand(managed, msg, content, ctx) {
             return true;
         }
         try {
-            const { spawnSync } = await import('node:child_process');
-            const statusResult = spawnSync('git', ['status', '-s'], {
-                cwd,
-                encoding: 'utf8',
-                timeout: 5000,
-            });
-            if (statusResult.status !== 0) {
-                const err = String(statusResult.stderr || statusResult.error || 'Unknown error');
-                if (err.includes('not a git repository') || err.includes('not in a git')) {
-                    await sendUserVisible(msg, '❌ Not a git repository.').catch(() => { });
-                }
-                else {
-                    await sendUserVisible(msg, `❌ git status failed: ${err.slice(0, 200)}`).catch(() => { });
-                }
-                return true;
-            }
-            const statusOut = String(statusResult.stdout || '').trim();
-            const branchResult = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-                cwd,
-                encoding: 'utf8',
-                timeout: 2000,
-            });
-            const branch = branchResult.status === 0 ? String(branchResult.stdout || '').trim() : 'unknown';
-            if (!statusOut) {
-                await sendUserVisible(msg, `📁 \`${cwd}\`\n🌿 Branch: \`${branch}\`\n\n✅ Working tree clean`).catch(() => { });
-                return true;
-            }
-            const lines = statusOut.split('\n').slice(0, 30);
-            const truncated = statusOut.split('\n').length > 30;
-            const formatted = lines
-                .map((line) => `\`${line.slice(0, 2)}\` ${line.slice(3)}`)
-                .join('\n');
-            await sendUserVisible(msg, `📁 \`${cwd}\`\n🌿 Branch: \`${branch}\`\n\n\`\`\`\n${formatted}${truncated ? '\n...' : ''}\`\`\``).catch(() => { });
+            await send(await gitStatusCommand(cwd));
         }
         catch (e) {
             await sendUserVisible(msg, `❌ git status failed: ${e?.message ?? String(e)}`).catch(() => { });
         }
         return true;
     }
+    // ── Discord-only commands (runtime/infra) ──────────────────────────
     if (content === '/hosts') {
         try {
             const { loadRuntimes, redactConfig } = await import('../runtime/store.js');
-            const config = await loadRuntimes();
-            const redacted = redactConfig(config);
+            const rtConfig = await loadRuntimes();
+            const redacted = redactConfig(rtConfig);
             if (!redacted.hosts.length) {
                 await sendUserVisible(msg, 'No hosts configured. Use `idlehands hosts add` in CLI.').catch(() => { });
                 return true;
@@ -492,8 +265,8 @@ export async function handleTextCommand(managed, msg, content, ctx) {
     if (content === '/backends') {
         try {
             const { loadRuntimes, redactConfig } = await import('../runtime/store.js');
-            const config = await loadRuntimes();
-            const redacted = redactConfig(config);
+            const rtConfig = await loadRuntimes();
+            const redacted = redactConfig(rtConfig);
             if (!redacted.backends.length) {
                 await sendUserVisible(msg, 'No backends configured. Use `idlehands backends add` in CLI.').catch(() => { });
                 return true;
@@ -515,12 +288,12 @@ export async function handleTextCommand(managed, msg, content, ctx) {
     if (content === '/models' || content === '/rtmodels') {
         try {
             const { loadRuntimes } = await import('../runtime/store.js');
-            const config = await loadRuntimes();
-            if (!config.models.length) {
+            const rtConfig = await loadRuntimes();
+            if (!rtConfig.models.length) {
                 await sendUserVisible(msg, 'No runtime models configured.').catch(() => { });
                 return true;
             }
-            const enabledModels = config.models.filter((m) => m.enabled);
+            const enabledModels = rtConfig.models.filter((mod) => mod.enabled);
             if (!enabledModels.length) {
                 await sendUserVisible(msg, 'No enabled runtime models. Use `idlehands models enable <id>` in CLI.').catch(() => { });
                 return true;
@@ -528,10 +301,10 @@ export async function handleTextCommand(managed, msg, content, ctx) {
             const { ActionRowBuilder, ButtonBuilder, ButtonStyle } = await import('discord.js');
             const rows = [];
             let currentRow = new ActionRowBuilder();
-            for (const m of enabledModels) {
+            for (const mod of enabledModels) {
                 const btn = new ButtonBuilder()
-                    .setCustomId(`model_switch:${m.id}`)
-                    .setLabel(m.display_name.slice(0, 80))
+                    .setCustomId(`model_switch:${mod.id}`)
+                    .setLabel(mod.display_name.slice(0, 80))
                     .setStyle(ButtonStyle.Primary);
                 currentRow.addComponents(btn);
                 if (currentRow.components.length >= 5) {
@@ -594,17 +367,17 @@ export async function handleTextCommand(managed, msg, content, ctx) {
             const { loadRuntimes } = await import('../runtime/store.js');
             const rtConfig = await loadRuntimes();
             const active = await loadActiveRuntime();
-            const result = plan({ modelId, mode: 'live' }, rtConfig, active);
-            if (!result.ok) {
-                await sendUserVisible(msg, `❌ Plan failed: ${result.reason}`).catch(() => { });
+            const planResult = plan({ modelId, mode: 'live' }, rtConfig, active);
+            if (!planResult.ok) {
+                await sendUserVisible(msg, `❌ Plan failed: ${planResult.reason}`).catch(() => { });
                 return true;
             }
-            if (result.reuse) {
+            if (planResult.reuse) {
                 await sendUserVisible(msg, '✅ Runtime already active and healthy.').catch(() => { });
                 return true;
             }
-            const statusMsg = await sendUserVisible(msg, `⏳ Switching to \`${result.model.display_name}\`...`).catch(() => null);
-            const execResult = await execute(result, {
+            const statusMsg = await sendUserVisible(msg, `⏳ Switching to \`${planResult.model.display_name}\`...`).catch(() => null);
+            const execResult = await execute(planResult, {
                 onStep: async (step, status) => {
                     if (status === 'done' && statusMsg) {
                         await statusMsg.edit(`⏳ ${step.description}... ✓`).catch(() => { });
@@ -617,10 +390,10 @@ export async function handleTextCommand(managed, msg, content, ctx) {
             });
             if (execResult.ok) {
                 if (statusMsg) {
-                    await statusMsg.edit(`✅ Switched to \`${result.model.display_name}\``).catch(() => { });
+                    await statusMsg.edit(`✅ Switched to \`${planResult.model.display_name}\``).catch(() => { });
                 }
                 else {
-                    await sendUserVisible(msg, `✅ Switched to \`${result.model.display_name}\``).catch(() => { });
+                    await sendUserVisible(msg, `✅ Switched to \`${planResult.model.display_name}\``).catch(() => { });
                 }
             }
             else {
@@ -648,186 +421,11 @@ const DISCORD_RATE_LIMIT_MS = 15_000;
 export async function handleDiscordAnton(managed, msg, content, ctx) {
     const { sendUserVisible } = ctx;
     const args = content.replace(/^\/anton\s*/, '').trim();
-    const sub = firstToken(args);
-    if (!sub || sub === 'status') {
-        if (!managed.antonActive) {
-            await sendUserVisible(msg, 'No Anton run in progress.').catch(() => { });
-        }
-        else if (managed.antonAbortSignal?.aborted) {
-            await sendUserVisible(msg, '🛑 Anton is stopping. Please wait for the current attempt to unwind.').catch(() => { });
-        }
-        else if (managed.antonProgress) {
-            const line1 = formatProgressBar(managed.antonProgress);
-            if (managed.antonProgress.currentTask) {
-                await sendUserVisible(msg, `${line1}\n\n**Working on:** *${managed.antonProgress.currentTask}* (Attempt ${managed.antonProgress.currentAttempt})`).catch(() => { });
-            }
-            else {
-                await sendUserVisible(msg, line1).catch(() => { });
-            }
-        }
-        else {
-            await sendUserVisible(msg, '🤖 Anton is running (no progress data yet).').catch(() => { });
-        }
-        return;
-    }
-    if (sub === 'stop') {
-        if (!managed.antonActive || !managed.antonAbortSignal) {
-            await sendUserVisible(msg, 'No Anton run in progress.').catch(() => { });
-            return;
-        }
-        managed.lastActivity = Date.now();
-        managed.antonAbortSignal.aborted = true;
-        await sendUserVisible(msg, '🛑 Anton stop requested.').catch(() => { });
-        return;
-    }
-    if (sub === 'last') {
-        if (!managed.antonLastResult) {
-            await sendUserVisible(msg, 'No previous Anton run.').catch(() => { });
-            return;
-        }
-        await sendUserVisible(msg, formatRunSummary(managed.antonLastResult)).catch(() => { });
-        return;
-    }
-    const filePart = sub === 'run' ? args.replace(/^\S+\s*/, '').trim() : args;
-    if (!filePart) {
-        await sendUserVisible(msg, '/anton <file> — start | /anton status | /anton stop | /anton last').catch(() => { });
-        return;
-    }
-    if (managed.antonActive) {
-        const staleMs = Date.now() - managed.lastActivity;
-        if (staleMs > 120_000) {
-            managed.antonActive = false;
-            managed.antonAbortSignal = null;
-            managed.antonProgress = null;
-            await sendUserVisible(msg, '♻️ Recovered stale Anton run state. Starting a fresh run...').catch(() => { });
-        }
-        else {
-            const runningMsg = managed.antonAbortSignal?.aborted
-                ? '🛑 Anton is still stopping. Please wait a moment, then try again.'
-                : '⚠️ Anton is already running. Use /anton stop first.';
-            await sendUserVisible(msg, runningMsg).catch(() => { });
-            return;
-        }
-    }
-    const cwd = managed.config.dir || process.cwd();
-    const filePath = path.resolve(cwd, filePart);
-    try {
-        await fs.stat(filePath);
-    }
-    catch {
-        await sendUserVisible(msg, `File not found: ${filePath}`).catch(() => { });
-        return;
-    }
-    const defaults = managed.config.anton || {};
-    const runConfig = {
-        taskFile: filePath,
-        projectDir: defaults.project_dir || cwd,
-        maxRetriesPerTask: defaults.max_retries ?? 3,
-        maxIterations: defaults.max_iterations ?? 200,
-        taskMaxIterations: defaults.task_max_iterations ?? 50,
-        taskTimeoutSec: defaults.task_timeout_sec ?? 600,
-        totalTimeoutSec: defaults.total_timeout_sec ?? 7200,
-        maxTotalTokens: defaults.max_total_tokens ?? Infinity,
-        maxPromptTokensPerAttempt: defaults.max_prompt_tokens_per_attempt ?? 128_000,
-        autoCommit: defaults.auto_commit ?? true,
-        branch: false,
-        allowDirty: false,
-        aggressiveCleanOnFail: false,
-        verifyAi: defaults.verify_ai ?? true,
-        verifyModel: undefined,
-        decompose: defaults.decompose ?? true,
-        maxDecomposeDepth: defaults.max_decompose_depth ?? 2,
-        maxTotalTasks: defaults.max_total_tasks ?? 500,
-        buildCommand: defaults.build_command ?? undefined,
-        testCommand: defaults.test_command ?? undefined,
-        lintCommand: defaults.lint_command ?? undefined,
-        skipOnFail: defaults.skip_on_fail ?? false,
-        skipOnBlocked: defaults.skip_on_blocked ?? true,
-        rollbackOnFail: defaults.rollback_on_fail ?? false,
-        maxIdenticalFailures: defaults.max_identical_failures ?? 5,
-        approvalMode: (defaults.approval_mode ?? 'yolo'),
-        verbose: false,
-        dryRun: false,
-    };
-    const abortSignal = { aborted: false };
-    managed.antonActive = true;
-    managed.antonAbortSignal = abortSignal;
-    managed.antonProgress = null;
-    let lastProgressAt = 0;
+    const m = managed;
     const channel = msg.channel;
-    const progress = {
-        onTaskStart(task, attempt, prog) {
-            managed.antonProgress = prog;
-            managed.lastActivity = Date.now();
-            const now = Date.now();
-            if (now - lastProgressAt >= DISCORD_RATE_LIMIT_MS) {
-                lastProgressAt = now;
-                channel.send(formatTaskStart(task, attempt, prog)).catch(() => { });
-            }
-        },
-        onTaskEnd(task, result, prog) {
-            managed.antonProgress = prog;
-            managed.lastActivity = Date.now();
-            const now = Date.now();
-            if (now - lastProgressAt >= DISCORD_RATE_LIMIT_MS) {
-                lastProgressAt = now;
-                channel.send(formatTaskEnd(task, result, prog)).catch(() => { });
-            }
-        },
-        onTaskSkip(task, reason) {
-            managed.lastActivity = Date.now();
-            channel.send(formatTaskSkip(task, reason)).catch(() => { });
-        },
-        onRunComplete(result) {
-            managed.lastActivity = Date.now();
-            managed.antonLastResult = result;
-            managed.antonActive = false;
-            managed.antonAbortSignal = null;
-            managed.antonProgress = null;
-            channel.send(formatRunSummary(result)).catch(() => { });
-        },
-        onHeartbeat() {
-            managed.lastActivity = Date.now();
-        },
-        onToolLoop(taskText, event) {
-            managed.lastActivity = Date.now();
-            if (defaults.progress_events !== false) {
-                channel.send(formatToolLoopEvent(taskText, event)).catch(() => { });
-            }
-        },
-        onCompaction(taskText, event) {
-            managed.lastActivity = Date.now();
-            if (defaults.progress_events !== false && event.droppedMessages >= 5) {
-                channel.send(formatCompactionEvent(taskText, event)).catch(() => { });
-            }
-        },
-        onVerification(taskText, verification) {
-            managed.lastActivity = Date.now();
-            if (defaults.progress_events !== false && !verification.passed) {
-                channel.send(formatVerificationDetail(taskText, verification)).catch(() => { });
-            }
-        },
-    };
-    let pendingCount = 0;
-    try {
-        const tf = await parseTaskFile(filePath);
-        pendingCount = tf.pending.length;
-    }
-    catch { }
-    await sendUserVisible(msg, `🤖 Anton started on ${filePart} (${pendingCount} tasks pending)`).catch(() => { });
-    runAnton({
-        config: runConfig,
-        idlehandsConfig: managed.config,
-        progress,
-        abortSignal,
-        vault: managed.session.vault,
-        lens: managed.session.lens,
-    }).catch((err) => {
-        managed.lastActivity = Date.now();
-        managed.antonActive = false;
-        managed.antonAbortSignal = null;
-        managed.antonProgress = null;
-        channel.send(`Anton error: ${err.message}`).catch(() => { });
-    });
+    const result = await antonCommand(m, args, (t) => { channel.send(t).catch(() => { }); }, DISCORD_RATE_LIMIT_MS);
+    const text = formatMarkdown(result);
+    if (text)
+        await sendUserVisible(msg, text).catch(() => { });
 }
 //# sourceMappingURL=discord-commands.js.map