@curie-agent/tui 0.2.4 → 0.3.0

package/dist/src/slash-commands.js

@@ -1,4 +1,37 @@
-import { pickNextSchedule, scheduleLabel } from '@curie-agent/core';
+import { pickNextSchedule } from '@curie-agent/core';
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/** Resolve the unified task file path for a scope. */
+function resolveTaskPath(scope, cwd) {
+    if (scope === 'personal')
+        return join(homedir(), '.curie-agent', 'tasks.json');
+    return join(cwd, 'tasks.json');
+}
+/** Read tasks file; falls back to legacy todo.json. Returns null if neither exists. */
+function readTaskJson(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, 'utf-8');
+        const data = JSON.parse(raw);
+        if (Array.isArray(data.tasks))
+            return data;
+        // Legacy format — check for plain array at root? No, legacy is {tasks: []} with no version/schema.
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Normalize a legacy task record (missing mode/scope) to UnifiedTask fields. */
+function normalizeTaskRecord(t) {
+    if (!t.mode)
+        t.mode = 'human';
+    if (!t.scope)
+        t.scope = 'personal';
+    return t;
+}
 const THINKING_BUDGET_MAP = {
     low: 2_000,
     medium: 6_000,
@@ -7,30 +40,42 @@ const THINKING_BUDGET_MAP = {
     auto: 0,
 };
 export const SLASH_COMMANDS = [
-    { name: 'status', description: 'Show version, model, and account info', usage: '/status' },
-    { name: 'help', description: 'Show all available commands', usage: '/help' },
-    { name: 'debug', description: 'Toggle debug logging', usage: '/debug [on|off]' },
-    { name: 'statusline', description: 'Toggle status line display', usage: '/statusline [on|off]' },
-    { name: 'theme', description: 'Change color theme', usage: '/theme <name>' },
-    { name: 'memory', description: 'View memory file sizes or capture a memory', usage: '/memory [status|add]' },
-    { name: 'stats', description: 'Daily usage, sessions, streaks', usage: '/stats' },
-    { name: 'context', description: 'Visual grid showing context window usage', usage: '/context [messages|compact [detailed|brief]]' },
-    { name: 'model', description: 'Switch AI model, set pricing or context window', usage: '/model <model|pricing in;out|windows tokens>' },
-    { name: 'effort', description: 'Set reasoning effort level', usage: '/effort <low|medium|high|max|auto>' },
-    { name: 'mode', description: 'Set approval mode', usage: '/mode <manual|plan|auto-edit|full-auto|yolo>' },
-    { name: 'agent', description: 'Launch external AI agent', usage: '/agent <prompt>' },
-    { name: 'remind', description: 'Create a reminder', usage: '/remind <message at time>' },
-    { name: 'cron', description: 'Manage reminders', usage: '/cron <list|delete|clear>' },
-    { name: 'channels', description: 'Manage Telegram channel config', usage: '/channels <list|set-bot-token|set-user-id|set-chat-id|disconnect>' },
-    { name: 'tools', description: 'View/set tool call limits per turn', usage: '/tools [tools_per_call [websearch_per_call]]' },
-    { name: 'websearch', description: 'View/set web search+fetch limit per turn', usage: '/websearch [count]' },
-    { name: 'mcp', description: 'Manage MCP server connections', usage: '/mcp <list|add|remove|reload>' },
-    { name: 'exit', description: 'Exit curie-agent', usage: '/exit' },
-    { name: 'provider', description: 'Switch AI provider', usage: '/provider <anthropic|openai|google|local|ollama|openrouter>' },
-    { name: 'heartbeat', description: 'Manage heartbeat cycle', usage: '/heartbeat <status|enable|disable|intraday|daily|weekly|monthly|now>' },
-    { name: 'init', description: 'Run the setup wizard', usage: '/init' },
-    { name: 'snapshots', description: 'List recent git snapshots for recovery', usage: '/snapshots' },
-    { name: 'revert', description: 'Revert to a git snapshot (index, default: most recent)', usage: '/revert [index]' },
+    // General
+    { name: 'status', description: 'Show version, model, and account info', usage: '/status', category: 'General' },
+    { name: 'help', description: 'Show all available commands', usage: '/help', category: 'General' },
+    { name: 'init', description: 'Run the setup wizard', usage: '/init', category: 'General' },
+    { name: 'exit', description: 'Exit curie-agent', usage: '/exit', category: 'General' },
+    // Model & Provider
+    { name: 'provider', description: 'Switch AI provider', usage: '/provider <anthropic|openai|google|local|ollama|openrouter>', category: 'Model & Provider' },
+    { name: 'model', description: 'Switch AI model, set pricing or context window', usage: '/model <model|pricing in;out|window tokens>', category: 'Model & Provider' },
+    { name: 'effort', description: 'Set reasoning effort level', usage: '/effort <low|medium|high|max|auto>', category: 'Model & Provider' },
+    { name: 'mode', description: 'Set approval mode', usage: '/mode <plan|edit|auto|yolo>', category: 'Model & Provider' },
+    // Display
+    { name: 'theme', description: 'Change color theme', usage: '/theme <name>', category: 'Display' },
+    { name: 'debug', description: 'Toggle debug logging', usage: '/debug [on|off]', category: 'Display' },
+    { name: 'statusline', description: 'Toggle status line display', usage: '/statusline [on|off]', category: 'Display' },
+    // Knowledge
+    { name: 'memory', description: 'View memory file sizes or capture a memory', usage: '/memory [status|add]', category: 'Knowledge' },
+    { name: 'todo', description: 'Manage tasks in todo.json', usage: '/todo <list|add|complete|remove>', category: 'Knowledge' },
+    { name: 'stats', description: 'Daily usage, sessions, streaks', usage: '/stats', category: 'Knowledge' },
+    { name: 'context', description: 'Visual grid showing context window usage, compaction, autocompaction', usage: '/context [auto|messages|compact [detailed|brief]]', category: 'Knowledge' },
+    { name: 'wiki', description: 'Open the wiki tab or run a wiki operation', usage: '/wiki [list|search <query>|lint|status]', category: 'Knowledge' },
+    // Automation
+    { name: 'remind', description: 'Create a reminder', usage: '/remind <message at time>', category: 'Automation' },
+    { name: 'cron', description: 'Manage reminders', usage: '/cron <list|delete|clear>', category: 'Automation' },
+    { name: 'task', description: 'Schedule an agent task', usage: '/task <create|list|delete>', category: 'Automation' },
+    { name: 'heartbeat', description: 'Manage heartbeat cycle', usage: '/heartbeat <status|enable|disable|intraday|daily|weekly|monthly|dreaming|now>', category: 'Automation' },
+    // Tools
+    { name: 'agent', description: 'Launch external AI agent', usage: '/agent <prompt>', category: 'Tools' },
+    { name: 'tools', description: 'View/set tool call limits per turn', usage: '/tools [tools_per_call [websearch_per_call]]', category: 'Tools' },
+    { name: 'websearch', description: 'View/set web search+fetch limit per turn', usage: '/websearch [count]', category: 'Tools' },
+    { name: 'mcp', description: 'Manage MCP server connections', usage: '/mcp <list|add|remove|reload>', category: 'Tools' },
+    { name: 'skill', description: 'List or show available skills', usage: '/skill [name]', category: 'Tools' },
+    // Communication
+    { name: 'channels', description: 'Manage Telegram channel config', usage: '/channels <list|set-bot-token|set-user-id|set-chat-id|disconnect>', category: 'Communication' },
+    // Safety
+    { name: 'snapshots', description: 'List recent git snapshots for recovery', usage: '/snapshots', category: 'Safety' },
+    { name: 'revert', description: 'Revert to a git snapshot (index, default: most recent)', usage: '/revert [index]', category: 'Safety' },
 ];
 export function parseSlashCommand(input) {
     const trimmed = input.trim();
@@ -59,6 +104,8 @@ export async function handleSlashCommand(cmd, args, ctx) {
             return handleTheme(args);
         case 'memory':
             return handleMemory(args, ctx);
+        case 'todo':
+            return handleTodo(args, ctx);
         case 'stats':
             return { type: 'switch_tab', tab: 'stats', message: 'Switched to Stats tab' };
         case 'context':
@@ -78,6 +125,8 @@ export async function handleSlashCommand(cmd, args, ctx) {
             return handleRemind(args, ctx);
         case 'cron':
             return handleCron(args, ctx);
+        case 'task':
+            return handleTask(args, ctx);
         case 'channels':
             return handleChannels(args, ctx);
         case 'mcp':
@@ -103,6 +152,8 @@ export async function handleSlashCommand(cmd, args, ctx) {
             return handleSnapshots(ctx);
         case 'revert':
             return handleRevert(args, ctx);
+        case 'skill':
+            return handleSkill(args, ctx);
         default:
             return {
                 type: 'message',
@@ -110,9 +161,112 @@ export async function handleSlashCommand(cmd, args, ctx) {
             };
     }
 }
+function handleSkill(args, ctx) {
+    const listSkillsFn = ctx.listSkills;
+    if (!listSkillsFn) {
+        return { type: 'message', message: 'Skills discovery is not available in this context.' };
+    }
+    const skills = listSkillsFn(ctx.cwd);
+    if (!args.trim()) {
+        if (skills.length === 0) {
+            return {
+                type: 'message',
+                message: [
+                    'No skills found.',
+                    '',
+                    'Skills are SKILL.md files in:',
+                    '  ~/.curie-agent/skills/         (global)',
+                    '  <cwd>/.curie-agent/skills/  (project)',
+                    '',
+                    'Directory format: skill-name/SKILL.md',
+                    'Flat format:      skill-name-SKILL.md',
+                ].join('\n'),
+            };
+        }
+        const lines = [`Available Skills (${skills.length}):`];
+        for (const s of skills) {
+            const source = s.source === 'project' ? '[project]' : '[global]';
+            const desc = s.description.length > 80 ? s.description.slice(0, 77) + '...' : s.description;
+            lines.push(`  ${s.name} ${source}`);
+            lines.push(`    ${desc}`);
+        }
+        lines.push('');
+        lines.push('Use /skill <name> to see full details.');
+        return { type: 'message', message: lines.join('\n') };
+    }
+    const name = args.trim().toLowerCase();
+    const skill = skills.find(s => s.name.toLowerCase() === name);
+    if (!skill) {
+        const available = skills.map(s => s.name).join(', ');
+        return { type: 'message', message: `Skill "${name}" not found. Available: ${available}` };
+    }
+    try {
+        const content = readFileSync(skill.filePath, 'utf-8');
+        const bodyStart = content.indexOf('---', 3);
+        const body = bodyStart > 0 ? content.slice(bodyStart + 3).trim() : content;
+        return {
+            type: 'message',
+            message: [
+                `## ${skill.name} (${skill.source})`,
+                `Description: ${skill.description}`,
+                `Source: ${skill.filePath}`,
+                '',
+                '---',
+                body,
+            ].join('\n'),
+        };
+    }
+    catch {
+        return { type: 'message', message: `Could not read skill file: ${skill.filePath}` };
+    }
+}
+function validatePricingString(cost) {
+    if (!cost)
+        return false;
+    if (!cost.includes('|')) {
+        const [inStr = '', outStr = ''] = cost.split(';');
+        const inC = parseFloat(inStr);
+        const outC = parseFloat(outStr);
+        return !isNaN(inC) && !isNaN(outC) && inC >= 0 && outC >= 0;
+    }
+    const tiers = cost.split('|').map(s => s.trim());
+    const firstPair = (tiers[0] ?? '').split(';');
+    const inStr = firstPair[0] ?? '';
+    const outStr = firstPair[1] ?? '';
+    if (isNaN(parseFloat(inStr)) || isNaN(parseFloat(outStr)))
+        return false;
+    for (let i = 1; i < tiers.length; i++) {
+        const tier = tiers[i];
+        const idx = tier.indexOf('<');
+        if (idx === -1)
+            return false;
+        const threshold = parseInt(tier.substring(0, idx).trim(), 10);
+        const rest = tier.substring(idx + 1).trim();
+        const [inStr2 = '', outStr2 = ''] = rest.split(';');
+        const tierIn = parseFloat(inStr2);
+        const tierOut = parseFloat(outStr2);
+        if (isNaN(threshold) || isNaN(tierIn) || isNaN(tierOut) || threshold < 0 || tierIn < 0 || tierOut < 0)
+            return false;
+    }
+    return true;
+}
+function formatPricingDisplay(cost) {
+    if (!cost)
+        return '';
+    if (!cost.includes('|')) {
+        const [inStr = '', outStr = ''] = cost.split(';');
+        return `Pricing: $${inStr} in / $${outStr} out per 1M`;
+    }
+    const tiers = cost.split('|').map(s => s.trim());
+    const firstPair = (tiers[0] ?? '').split(';');
+    const inStr = firstPair[0] ?? '?';
+    const outStr = firstPair[1] ?? '?';
+    return `Pricing: $${inStr} in / $${outStr} out per 1M (${tiers.length} tier${tiers.length > 1 ? 's' : ''})`;
+}
 function handleStatus(ctx) {
-    const toolsPerCall = ctx.settings.TOOLS_PER_CALL ?? 10;
-    const websearchPerCall = ctx.settings.WEBSEARCH_PER_CALL ?? 5;
+    const toolsPerCall = ctx.settings.tools_per_call ?? 10;
+    const websearchPerCall = ctx.settings.websearch_per_call ?? 5;
+    const modelCost = ctx.settings.providers?.[ctx.settings.current_provider]?.model_cost;
     const lines = [
         `curie-agent v${ctx.version}`,
         `Model: ${ctx.model}`,
@@ -124,16 +278,34 @@ function handleStatus(ctx) {
             : null,
         `Tools per turn: ${toolsPerCall}`,
         `WebSearch per turn: ${websearchPerCall}`,
-        ctx.settings.MODEL_COST
-            ? `Pricing: $${ctx.settings.MODEL_COST.split(';')[0]} in / $${ctx.settings.MODEL_COST.split(';')[1]} out per 1M`
+        modelCost
+            ? formatPricingDisplay(modelCost)
             : null,
     ].filter(Boolean);
     return { type: 'message', message: lines.join('\n') };
 }
 function handleHelp() {
-    const lines = ['Slash commands:'];
+    const lines = [];
+    // Group by category
+    const groups = {};
     for (const cmd of SLASH_COMMANDS) {
-        lines.push(`  ${cmd.usage.padEnd(24)} ${cmd.description}`);
+        if (!groups[cmd.category])
+            groups[cmd.category] = [];
+        groups[cmd.category].push(cmd);
+    }
+    // Calculate column width per group
+    const colWidth = {};
+    for (const [cat, cmds] of Object.entries(groups)) {
+        colWidth[cat] = Math.min(Math.max(...cmds.map((c) => c.usage.length)) + 4, 40);
+    }
+    for (const [cat, cmds] of Object.entries(groups)) {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(cat);
+        const w = colWidth[cat];
+        for (const cmd of cmds) {
+            lines.push(`  ${cmd.usage.padEnd(w)} ${cmd.description}`);
+        }
     }
     return { type: 'message', message: lines.join('\n') };
 }
@@ -171,14 +343,15 @@ function handleTheme(args) {
     return { type: 'update_theme', theme, message: `Theme changed to: ${theme}` };
 }
 function handleModel(args, settings) {
-    const MODEL_COST_DEFAULT = '(not set)';
     const WINDOW_DEFAULT = 200_000;
+    const getModelCost = (s) => s?.providers?.[s.current_provider]?.model_cost;
+    const getWindow = (s) => s?.providers?.[s.current_provider]?.model_context_window;
     if (!args) {
-        const cost = settings?.MODEL_COST ?? MODEL_COST_DEFAULT;
-        const window = settings?.MODEL_CONTEXT_WINDOW ?? WINDOW_DEFAULT;
+        const cost = getModelCost(settings) ?? '(not set)';
+        const window = getWindow(settings) ?? WINDOW_DEFAULT;
         return {
             type: 'message',
-            message: `Usage: /model <model>\n  /model pricing [in;out]        — set custom per-million pricing (e.g. "0.5;2.0")\n  /model windows <tokens>       — set max context window\n\nCurrent: pricing=${cost}  window=${window} tokens`,
+            message: `Usage: /model <model>\n  /model pricing [in;out]        — set custom per-million pricing (e.g. "0.5;2.0" or "0.5;2.0|200000<1.0;4.0")\n  /model window <tokens>       — set max context window\n\nCurrent: pricing=${cost}  window=${window} tokens`,
         };
     }
     const parts = args.trim().split(/\s+/);
@@ -187,21 +360,30 @@ function handleModel(args, settings) {
     switch (sub) {
         case 'pricing': {
             if (!rest) {
-                const cost = settings?.MODEL_COST ?? MODEL_COST_DEFAULT;
-                return { type: 'message', message: `Usage: /model pricing <in;out>\nExample: /model pricing 0.5;2.0\nCurrent: ${cost}` };
+                const cost = getModelCost(settings) ?? '(not set)';
+                return { type: 'message', message: `Usage: /model pricing <in;out>\n  /model pricing <in;out|threshold<input;out>...\nExample: /model pricing 0.5;2.0\n  /model pricing 0.5;2.0|200000<1.0;4.0\nCurrent: ${cost}` };
             }
-            const [inStr, outStr] = rest.split(';');
-            const inCost = parseFloat(inStr ?? '');
-            const outCost = parseFloat(outStr ?? '');
-            if (isNaN(inCost) || isNaN(outCost) || inCost < 0 || outCost < 0) {
-                return { type: 'message', message: `Invalid pricing: "${rest}". Use format: <in;out> (per million tokens, e.g. "0.5;2.0").` };
+            const isValidPricing = validatePricingString(rest);
+            if (!isValidPricing) {
+                return { type: 'message', message: `Invalid pricing: "${rest}". Use format: <in;out> or <in;out|threshold<input;out> (per million tokens, e.g. "0.5;2.0" or "0.5;2.0|200000<1.0;4.0").` };
             }
-            return { type: 'update_model_cost', modelCost: rest, message: `Model pricing set to: $${inCost} in / $${outCost} out per 1M tokens` };
+            const [inStr = ''] = rest.split(';');
+            const inCost = parseFloat(inStr);
+            const firstTier = rest.split('|')[0]?.split(';');
+            const outCost = firstTier ? parseFloat(firstTier[1] ?? '') : NaN;
+            const tierCount = rest.includes('|') ? rest.split('|').length : 1;
+            return {
+                type: 'update_model_cost',
+                modelCost: rest,
+                message: tierCount === 1
+                    ? `Model pricing set to: $${inCost} in / $${outCost} out per 1M tokens`
+                    : `Model pricing set to: ${tierCount} tiers, base $${inCost} in / $${outCost} out per 1M tokens`,
+            };
         }
-        case 'windows': {
+        case 'window': {
             if (!rest) {
-                const window = settings?.MODEL_CONTEXT_WINDOW ?? WINDOW_DEFAULT;
-                return { type: 'message', message: `Usage: /model windows <tokens>\nExample: /model windows 1000000\nCurrent: ${window}` };
+                const window = getWindow(settings) ?? WINDOW_DEFAULT;
+                return { type: 'message', message: `Usage: /model window <tokens>\nExample: /model window 1000000\nCurrent: ${window}` };
             }
             const windowSize = parseInt(rest, 10);
             if (isNaN(windowSize) || windowSize < 1024) {
@@ -313,88 +495,63 @@ function handleRemind(args, ctx) {
     if (!args) {
         return {
             type: 'message',
-            message: 'Usage: /remind <message at time>\nExamples: /remind "tomorrow at 7am make breakfast", /remind "in 30 minutes call mom"',
+            message: 'Usage: /remind <message at time>\nExample: /remind "tomorrow at 7am make breakfast"\nOr use /todo notify add "..." for the unified format.',
         };
     }
-    const cronManager = ctx.cronManager;
-    if (!cronManager) {
-        return {
-            type: 'message',
-            message: 'Reminder service not available. Please restart the application.',
-        };
+    const { parseReminderTime } = {};
+    try {
+        Object.assign(require('../../core/src/reminder-parser.js'), { parseReminderTime });
+    }
+    catch { /* module not available */ }
+    if (!parseReminderTime) {
+        return { type: 'message', message: `Could not parse time from: "${args}".\nUse /todo notify add "tomorrow at 7am make breakfast"` };
     }
-    const { parseReminderTime } = require('../../core/src/reminder-parser.js');
     const parsed = parseReminderTime(args);
     if (!parsed) {
-        return {
-            type: 'message',
-            message: `Could not parse time from: "${args}".\nTry: /remind "tomorrow at 7am make breakfast"`,
-        };
+        return { type: 'message', message: `Could not parse time from: "${args}".\nUse /todo notify add "tomorrow at 7am make breakfast"` };
     }
-    const task = cronManager.createReminder(parsed.message, parsed.scheduledAt);
-    const timeStr = new Date(task.scheduledAt).toLocaleString();
-    return {
-        type: 'message',
-        message: `Curie reminder:\nDate: ${timeStr}\n${parsed.message}\nID: ${task.id}`,
-    };
+    if (ctx.taskManager) {
+        ctx.taskManager.load();
+        const task = ctx.taskManager.create({ title: parsed.message, mode: 'notify', scope: 'personal', scheduled_at: parsed.scheduledAt });
+        return { type: 'message', message: `Reminder set:\nTime: ${new Date(task.scheduled_at).toLocaleString()}\nMessage: ${task.title}\nID: ${task.id}` };
+    }
+    return { type: 'message', message: 'Reminder service not available. Please restart the application.' };
 }
 function handleCron(args, ctx) {
-    const cronManager = ctx.cronManager;
-    if (!cronManager) {
-        return {
-            type: 'message',
-            message: 'Reminder service not available. Please restart the application.',
-        };
-    }
-    // Reload from disk before each command so tool-created reminders
-    // are visible even if the tool used a separate CronManager instance.
-    cronManager.load();
+    // /cron is an alias for viewing notify-mode tasks in the unified store.
     const parts = args.trim().split(/\s+/);
     const action = parts[0]?.toLowerCase();
     const rest = parts.slice(1).join(' ').trim();
+    if (!ctx.taskManager) {
+        return { type: 'message', message: 'Task service not available. Please restart the application.' };
+    }
+    ctx.taskManager.load();
     switch (action) {
         case 'list': {
-            const statusFilter = ['pending', 'fired', 'cancelled'].includes(rest) ? rest : undefined;
-            const tasks = cronManager.listReminders(statusFilter);
-            if (tasks.length === 0) {
-                return {
-                    type: 'message',
-                    message: statusFilter
-                        ? `No ${statusFilter} reminders.`
-                        : 'No reminders yet.\nUse /remind to create one.',
-                };
-            }
-            const lines = [`Reminders (${tasks.length}${statusFilter ? ` — ${statusFilter}` : ''}):`];
-            for (const t of tasks) {
-                const timeStr = new Date(t.scheduledAt).toLocaleString();
-                const statusEmoji = t.status === 'pending' ? '⏳' : t.status === 'fired' ? '✅' : '❌';
-                const label = t.schedule ? `[${scheduleLabel(t.schedule.type)}] ` : '';
-                lines.push(`  ${statusEmoji} ${label}${t.message}\n    Date: ${timeStr}\n    ID: ${t.id}`);
+            const allTasks = ctx.taskManager.list({ mode: 'notify' });
+            if (allTasks.length === 0)
+                return { type: 'message', message: 'No scheduled reminders.\nUse /todo notify add "..." to create one.' };
+            const lines = [`Reminders (${allTasks.length}):`];
+            for (const t of allTasks.sort((a, b) => Number(a.scheduled_at ?? 0) - Number(b.scheduled_at ?? 0))) {
+                const timeStr = t.scheduled_at ? new Date(t.scheduled_at).toLocaleString() : '—';
+                lines.push(`  ${t.status} ${t.title}\n    Time: ${timeStr}\n    ID: ${t.id.slice(0, 8)}`);
             }
             return { type: 'message', message: lines.join('\n') };
         }
         case 'delete': {
-            if (!rest) {
-                return {
-                    type: 'message',
-                    message: 'Usage: /cron delete <id>\nExample: /cron delete abc-123',
-                };
-            }
-            const result = cronManager.cancelReminder(rest);
-            if (!result) {
-                return { type: 'message', message: `No reminder found with ID: ${rest}` };
-            }
-            return { type: 'message', message: `Reminder cancelled.` };
+            if (!rest)
+                return { type: 'message', message: 'Usage: /cron delete <id>\nExample: /cron delete abc-123' };
+            const result = ctx.taskManager.cancelTask(rest);
+            if (result)
+                return { type: 'message', message: 'Reminder cancelled.' };
+            return { type: 'message', message: `No reminder found with ID: ${rest}` };
         }
         case 'clear': {
-            const removed = cronManager.clearCompleted();
-            return { type: 'message', message: `Cleared ${removed} completed reminder(s).` };
+            const removed = ctx.taskManager.clearCompleted();
+            return { type: 'message', message: `Cleared ${removed} completed task(s).` };
         }
         default:
-            return {
-                type: 'message',
-                message: `Unknown cron action: "${action}". Use: list, delete, clear`,
-            };
+            return handleTodo('list personal', ctx);
     }
 }
 function handleChannels(args, ctx) {
@@ -403,9 +560,9 @@ function handleChannels(args, ctx) {
     const rest = parts.slice(1).join(' ').trim();
     switch (sub) {
         case 'list': {
-            const token = ctx.settings.TELEGRAM_BOT_TOKEN;
-            const userId = ctx.settings.TELEGRAM_USER_ID;
-            const chatId = ctx.settings.TELEGRAM_CHAT_ID;
+            const token = ctx.settings.channels?.bot_token;
+            const userId = ctx.settings.channels?.user_id;
+            const chatId = ctx.settings.channels?.chat_id;
             const tokenMask = token && token.length > 8
                 ? token.slice(0, 8) + '...'
                 : token || '(not set)';
@@ -473,7 +630,7 @@ function handleMcp(args, ctx) {
     // Parse current MCP servers from settings
     let configs = {};
     try {
-        const raw = ctx.settings.MCP_SERVERS;
+        const raw = ctx.settings.mcp_servers;
         if (typeof raw === 'string' && raw.trim().length > 0) {
             configs = JSON.parse(raw);
         }
@@ -506,14 +663,16 @@ function handleMcp(args, ctx) {
                     detail = `url: ${c.url || '?'}`;
                 }
                 const client = ctx.mcpClients?.find((cl) => cl.serverId === id);
+                const wasFailed = ctx.mcpFailed?.includes(id);
                 if (!client) {
-                    lines.push(`  · ${id} (${name}) — ${transport}: ${detail} [not loaded]`);
+                    const status = wasFailed ? 'connection failed' : 'not running';
+                    lines.push(`  ⚠️  ${id} (${name}) — ${transport}: ${detail} [${status}]`);
                 }
                 else if (client.isConnected) {
-                    lines.push(`  ● ${id} (${name}) — ${transport}: ${detail} [connected]`);
+                    lines.push(`  ✅ ${id} (${name}) — ${transport}: ${detail}`);
                 }
                 else {
-                    lines.push(`  ○ ${id} (${name}) — ${transport}: ${detail} [disconnected]`);
+                    lines.push(`  ⚠️  ${id} (${name}) — ${transport}: ${detail} [disconnected]`);
                 }
             }
             return { type: 'message', message: lines.join('\n') };
@@ -573,7 +732,7 @@ function handleMcp(args, ctx) {
             if (Object.keys(env).length > 0)
                 cfg.env = env;
             configs[id] = cfg;
-            ctx.settings.MCP_SERVERS = configs;
+            ctx.settings.mcp_servers = configs;
             return { type: 'update_mcp', mcpServerId: id, mcpServers: JSON.stringify(configs, null, 2), message: `Added MCP server "${id}":\n\n${JSON.stringify(configs, null, 2)}\n\nRun /mcp reload to connect.` };
         }
         case 'remove': {
@@ -587,7 +746,7 @@ function handleMcp(args, ctx) {
                 return { type: 'message', message: `No MCP server found with ID: ${rest}` };
             }
             delete configs[rest];
-            ctx.settings.MCP_SERVERS = configs;
+            ctx.settings.mcp_servers = configs;
             return { type: 'update_mcp', mcpServerId: rest, message: `Removed MCP server "${rest}". Run /mcp reload to apply.` };
         }
         case 'reload': {
@@ -601,8 +760,8 @@ function handleMcp(args, ctx) {
     }
 }
 function handleTools(args, settings) {
-    const toolsPerCall = settings.TOOLS_PER_CALL ?? 10;
-    const websearchPerCall = settings.WEBSEARCH_PER_CALL ?? 5;
+    const toolsPerCall = settings.tools_per_call ?? 10;
+    const websearchPerCall = settings.websearch_per_call ?? 5;
     if (!args.trim()) {
         return {
             type: 'message',
@@ -629,7 +788,7 @@ function handleTools(args, settings) {
     return result;
 }
 function handleWebsearch(args, settings) {
-    const websearchPerCall = settings.WEBSEARCH_PER_CALL ?? 5;
+    const websearchPerCall = settings.websearch_per_call ?? 5;
     if (!args.trim()) {
         return {
             type: 'message',
@@ -679,6 +838,298 @@ function handleMemory(args, ctx) {
         }
     }
 }
+/**
+ * Parse /todo args: "/todo [scope:]add|list|complete|cancel|start|remove [title|id]"
+ * Optionally with mode keywords: "auto/add", "notify/add"
+ */
+function parseTodoArgs(args) {
+    const parts = args.trim().split(/\s+/);
+    if (!parts.length)
+        return { scope: 'project', action: '', titleOrId: '' };
+    let scope = 'project';
+    let action = '';
+    let idx = 0;
+    // First token: scope, mode keyword, or action
+    const first = parts[0].toLowerCase();
+    if (first === 'personal' || first === 'project') {
+        scope = first;
+        idx = 1;
+    }
+    else if (first === 'auto' || first === 'notify') {
+        // mode keyword: /todo auto add ..., /todo notify list ...
+        idx = 1;
+    }
+    // Second token: action or scope fallback
+    const second = parts[idx]?.toLowerCase() ?? '';
+    const actions = ['list', 'add', 'complete', 'cancel', 'start', 'remove'];
+    if (actions.includes(second)) {
+        action = second;
+        idx++;
+    }
+    else if (first === 'personal' || first === 'project') {
+        // no scope given — second token is the action, third is the content
+        if (actions.includes(second))
+            action = second;
+        idx += actions.includes(second) ? 1 : 0;
+    }
+    const titleOrId = parts.slice(idx).join(' ').trim();
+    return { scope, action, titleOrId };
+}
+/** Helper to read a tasks file (unified format), falls back to legacy todo.json. */
+function readTasksAtPath(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed.tasks))
+            return { tasks: parsed.tasks };
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Write a task record to file (unified format). */
+function writeTaskToFile(filePath, taskRecord) {
+    let data = readTasksAtPath(filePath);
+    if (!data) {
+        data = { tasks: [] };
+    }
+    // Update/insert the task
+    const idx = data.tasks.findIndex((t) => t.id === taskRecord.id);
+    if (idx >= 0) {
+        data.tasks[idx] = taskRecord;
+    }
+    else {
+        data.tasks.push(taskRecord);
+    }
+    writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+/** Remove a task from file by ID. */
+function removeTaskFromFile(filePath, id) {
+    if (!existsSync(filePath))
+        return false;
+    try {
+        const raw = readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const tasks = parsed.tasks;
+        if (!Array.isArray(tasks))
+            return false;
+        for (const t of tasks)
+            normalizeTaskRecord(t);
+        const idx = tasks.findIndex((t) => t.id === id);
+        if (idx === -1)
+            return false;
+        tasks.splice(idx, 1);
+        tasks.forEach((t, i) => { t.order = i; });
+        parsed.tasks = tasks;
+        writeFileSync(filePath, JSON.stringify(parsed, null, 2), 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Normalize and return the active+done task counts from a TasksData. */
+function getTaskCounts(tasks) {
+    const active = tasks.filter((t) => !['done', 'canceled'].includes(String(t.status ?? '')));
+    const doneCount = tasks.filter((t) => t.status === 'done').length;
+    return { active: active.length, done: doneCount };
+}
+function handleTodo(args, ctx) {
+    const parsed = parseTodoArgs(args);
+    const { scope, action, titleOrId } = parsed;
+    const path = resolveTaskPath(scope, ctx.cwd);
+    // Support both unified tasks.json and legacy todo.json
+    const fullPath = existsSync(path) ? path : (scope === 'personal'
+        ? join(homedir(), '.curie-agent', 'todo.json')
+        : join(ctx.cwd, 'todo.json'));
+    switch (action) {
+        case 'list': {
+            const data = readTasksAtPath(fullPath);
+            if (!data || !data.tasks.length) {
+                return { type: 'message', message: `No tasks in ${scope}.` };
+            }
+            // Normalize and filter
+            const normalizedTasks = data.tasks.map((t) => normalizeTaskRecord(t));
+            let tasks = normalizedTasks;
+            const active = tasks.filter((t) => !['done', 'canceled'].includes(String(t.status ?? '')));
+            const done = tasks.filter((t) => t.status === 'done');
+            // Auto-detect mode from title (for user convenience)
+            const lower = args.toLowerCase();
+            const hasModeKeyword = /auto/.test(lower) || /notify/.test(lower);
+            const lines = [`Tasks (${scope}) — ${active.length} active, ${done.length} done:`];
+            for (const t of active.sort((a, b) => Number(a.order ?? 0) - Number(b.order ?? 0))) {
+                const icon = String(t.status) === 'in_progress' ? '[*]' : '-';
+                const prio = (t.priority !== 'medium' && t.priority) ? ` [${t.priority}]` : '';
+                const modeCol = t.mode ? `[${String(t.mode).toUpperCase()}]` : '[MANUAL]';
+                const scheduledAt = typeof t.scheduled_at === 'number' ? t.scheduled_at : undefined;
+                const timeStr = scheduledAt ? ` (at ${new Date(scheduledAt).toLocaleString()})` : '';
+                lines.push(`  ${icon} ${String(t.id).slice(0, 8)} ${modeCol}${prio} ${t.title}${timeStr}`);
+            }
+            return { type: 'message', message: lines.join('\n') };
+        }
+        case 'add': {
+            if (!titleOrId) {
+                return {
+                    type: 'message',
+                    message: `Usage: /todo add <title>\nExample: /todo add "Finish the report"\n  /todo agent add "build at 3pm"     — agent executes it\n  /todo notify add "remind about X" — notification only`,
+                };
+            }
+            // Detect mode from keyword or natural language time parsing
+            let mode = 'human';
+            const lower = titleOrId.toLowerCase();
+            if (lower.startsWith('at ') || /\bat\b/.test(lower)) {
+                // Has time reference — try to parse with TaskManager
+                const taskMgr = ctx.taskManager;
+                let instruction;
+                // Check if "agent" was explicitly requested
+                if (/^agent\s+add\s*/i.test(args) || /^agent\b/.test(args)) {
+                    mode = 'agent';
+                }
+                else if (/^notify\s+add\s*/i.test(args) || /notify\s+/i.test(args)) {
+                    mode = 'notify';
+                }
+                const timeKeywordPattern = /^(agent|notify)\s*add\s*/i;
+                instruction = titleOrId.replace(timeKeywordPattern, '');
+                if (!instruction) {
+                    return { type: 'message', message: 'Usage: /todo add <title>\n  /todo agent add "build at 3pm"\n  /todo notify add "remind about X"' };
+                }
+                // Try natural language time parsing
+                let { parseReminderTime } = {};
+                try {
+                    parseReminderTime = require('../../core/src/reminder-parser.js').parseReminderTime;
+                }
+                catch { /* module not available */ }
+                if (mode === 'human' && parseReminderTime) {
+                    const parsed = parseReminderTime(instruction);
+                    if (parsed) {
+                        instruction = parsed.message;
+                        if (taskMgr) {
+                            taskMgr.load();
+                            taskMgr.create({ title: instruction, mode: 'agent', scope: 'personal', scheduled_at: parsed.scheduledAt });
+                            const timeStr = new Date(parsed.scheduledAt).toLocaleString();
+                            return { type: 'message', message: `Task scheduled:\nTime: ${timeStr}\nInstruction: ${instruction}` };
+                        }
+                    }
+                }
+                if (mode === 'notify' && parseReminderTime) {
+                    const parsed = parseReminderTime(instruction);
+                    if (parsed && taskMgr) {
+                        taskMgr.load();
+                        const task = taskMgr.create({ title: parsed.message, mode: 'notify', scope: 'personal', scheduled_at: parsed.scheduledAt });
+                        const timeStr = new Date(task.scheduled_at).toLocaleString();
+                        return { type: 'message', message: `Reminder scheduled:\nTime: ${timeStr}\nMessage: ${parsed.message}` };
+                    }
+                }
+                if (mode === 'agent' && parseReminderTime) {
+                    const parsed = parseReminderTime(instruction);
+                    if (parsed && taskMgr) {
+                        taskMgr.load();
+                        const task = taskMgr.create({ title: parsed.message, mode: 'agent', scope: 'personal', scheduled_at: parsed.scheduledAt });
+                        const timeStr = new Date(task.scheduled_at).toLocaleString();
+                        return { type: 'message', message: `Scheduled task:\nTime: ${timeStr}\nInstruction: ${parsed.message}` };
+                    }
+                }
+                // No time could be parsed — fall through to manual mode
+            }
+            else if (/^agent\s+add\s*/i.test(args) || /^agent\b/.test(args)) {
+                mode = 'agent';
+            }
+            else if (/^notify\s+add\s*/i.test(args) || /notify\s+/i.test(args)) {
+                mode = 'notify';
+            }
+            const title = (mode === 'human' ? titleOrId : titleOrId.replace(/^(agent|notify)\s+add\s*/i, '').trim()) || titleOrId;
+            if (!title)
+                return { type: 'message', message: `Usage: /todo add <title>\nExample: /todo add "Finish the report"` };
+            let data = readTasksAtPath(fullPath);
+            if (!data) {
+                data = { $schema: 'tasks.schema.json', version: 1, tasks: [] };
+            }
+            data.tasks = data.tasks.map((t) => normalizeTaskRecord(t));
+            const id = crypto.randomUUID();
+            const task = {
+                id,
+                title,
+                description: '',
+                status: 'todo',
+                priority: 'medium',
+                tags: [],
+                order: data.tasks.length,
+                created_at: new Date().toISOString(),
+                completed_at: null,
+            };
+            // Add mode and scope fields
+            task.mode = mode;
+            task.scope = scope;
+            data.tasks.push(task);
+            writeFileSync(fullPath, JSON.stringify(data, null, 2), 'utf-8');
+            const modePrefix = mode === 'human' ? '' : `[${mode}] `;
+            return { type: 'message', message: `${modePrefix}Added task: "${title}" (ID: ${id.slice(0, 8)})` };
+        }
+        case 'complete': {
+            if (!titleOrId)
+                return { type: 'message', message: 'Usage: /todo complete <id>' };
+            let data = readTasksAtPath(fullPath);
+            if (!data)
+                return { type: 'message', message: 'No tasks found.' };
+            data.tasks = data.tasks.map((t) => normalizeTaskRecord(t));
+            const idx = data.tasks.findIndex((t) => String(t.id) === titleOrId || String(t.id).startsWith(titleOrId));
+            if (idx === -1)
+                return { type: 'message', message: `Task not found: ${titleOrId}` };
+            data.tasks[idx].status = 'done';
+            data.tasks[idx].completed_at = new Date().toISOString();
+            writeFileSync(fullPath, JSON.stringify(data, null, 2), 'utf-8');
+            return { type: 'message', message: `Completed: "${data.tasks[idx].title}"` };
+        }
+        case 'cancel': {
+            if (!titleOrId)
+                return { type: 'message', message: 'Usage: /todo cancel <id>' };
+            let data = readTasksAtPath(fullPath);
+            if (!data)
+                return { type: 'message', message: 'No tasks found.' };
+            data.tasks = data.tasks.map((t) => normalizeTaskRecord(t));
+            const idx = data.tasks.findIndex((t) => String(t.id) === titleOrId || String(t.id).startsWith(titleOrId));
+            if (idx === -1)
+                return { type: 'message', message: `Task not found: ${titleOrId}` };
+            data.tasks[idx].status = 'canceled';
+            writeFileSync(fullPath, JSON.stringify(data, null, 2), 'utf-8');
+            return { type: 'message', message: `Canceled: "${data.tasks[idx].title}"` };
+        }
+        case 'start': {
+            if (!titleOrId)
+                return { type: 'message', message: 'Usage: /todo start <id>' };
+            let data = readTasksAtPath(fullPath);
+            if (!data)
+                return { type: 'message', message: 'No tasks found.' };
+            data.tasks = data.tasks.map((t) => normalizeTaskRecord(t));
+            const idx = data.tasks.findIndex((t) => String(t.id) === titleOrId || String(t.id).startsWith(titleOrId));
+            if (idx === -1)
+                return { type: 'message', message: `Task not found: ${titleOrId}` };
+            data.tasks[idx].status = 'in_progress';
+            writeFileSync(fullPath, JSON.stringify(data, null, 2), 'utf-8');
+            return { type: 'message', message: `Started: "${data.tasks[idx].title}"` };
+        }
+        case 'remove': {
+            if (!titleOrId)
+                return { type: 'message', message: 'Usage: /todo remove <id>' };
+            if (removeTaskFromFile(fullPath, titleOrId)) {
+                return { type: 'message', message: `Removed task: ${titleOrId.slice(0, 8)}` };
+            }
+            return { type: 'message', message: `Task not found: ${titleOrId}` };
+        }
+        default: {
+            if (!action) {
+                return {
+                    type: 'message',
+                    message: 'Task commands:\n  /todo list [personal|project]      — List tasks\n  /todo add <title>                   — Add a manual task\n  /todo auto add "X at Y"             — Agent executes X at Y\n  /todo notify add "remind about X"   — Notification only\n  /todo complete <id>                 — Mark done\n  /todo cancel <id>                   — Cancel a task\n  /todo start <id>                    — Start working on it\n  /todo remove <id>                   — Delete permanently',
+                };
+            }
+            return { type: 'message', message: `Unknown todo action: "${action}". Use: list, add, complete, cancel, start, remove` };
+        }
+    }
+}
 function formatChannelMessages(messages) {
     const lines = [`Conversation Messages (${messages.length}):`];
     const maxOutput = 8000;
@@ -692,7 +1143,9 @@ function formatChannelMessages(messages) {
                         : msg.role === 'system' ? 'System'
                             : msg.role === 'decision' ? 'Decision'
                                 : msg.role === 'heartbeat' ? 'Heartbeat'
-                                    : msg.role;
+                                    : msg.role === 'task' ? 'Task'
+                                        : msg.role === 'debug' ? 'Debug'
+                                            : msg.role;
         const titlePrefix = msg.title ? `[${msg.title}] ` : '';
         const truncated = msg.content.length > 300
             ? msg.content.slice(0, 300) + '...'
@@ -811,14 +1264,76 @@ function handleContext(ctx, args) {
                 messages: loopMsgs,
                 depth,
             },
-            message: `Compacting conversation (${depth} summary)...\nThe agent will process the summary and continue with a condensed context.`,
+            message: `Compacting conversation (${loopMsgs.length} messages)... This will use one AI turn to summarize your session. The agent will continue automatically.`,
         };
     }
+    // /context auto — autocompaction settings and controls
+    if (sub && (sub === 'auto' || sub.startsWith('auto '))) {
+        const parts = sub.split(/\s+/);
+        const action = parts[0]?.toLowerCase() ?? 'auto';
+        const arg1 = parts[1]?.toLowerCase();
+        const arg2 = parts[2];
+        const s = ctx.settings;
+        if (action === 'auto' && !arg1) {
+            // Show current settings
+            const lines = [
+                'Autocompaction Settings:',
+                `  Enabled: ${s.auto_compact?.enabled ?? 'on'}`,
+                `  Context fill threshold: ${s.auto_compact?.threshold ?? 75}%`,
+                `  Warning threshold: ${s.auto_compact?.warn_threshold ?? 60}%`,
+                `  Forced compaction threshold: ${s.auto_compact?.forced_threshold ?? 85}%`,
+                `  Pricing tier warning: ${s.pricing_tier_warn ?? 'on'}`,
+                '',
+                'Usage:',
+                '  /context auto on/off         — enable or disable autocompaction',
+                '  /context auto threshold <N>   — set compaction threshold (%)',
+                '  /context auto warn <N>        — set warning threshold (%)',
+                '  /context auto pricing on/off  — enable/disable pricing tier warnings',
+            ];
+            return { type: 'message', message: lines.join('\n') };
+        }
+        if (arg1 === 'on') {
+            ctx.settingsMgr?.update({ auto_compact: { ...s.auto_compact, enabled: 'on' } });
+            return { type: 'message', message: 'Autocompaction enabled.' };
+        }
+        if (arg1 === 'off') {
+            ctx.settingsMgr?.update({ auto_compact: { ...s.auto_compact, enabled: 'off' } });
+            return { type: 'message', message: 'Autocompaction disabled.' };
+        }
+        if (arg1 === 'threshold' && arg2) {
+            const pct = parseInt(arg2, 10);
+            if (isNaN(pct) || pct < 10 || pct > 99) {
+                return { type: 'message', message: 'Invalid threshold. Use a value between 10 and 99.' };
+            }
+            ctx.settingsMgr?.update({ auto_compact: { ...s.auto_compact, threshold: pct } });
+            return { type: 'message', message: `Compaction threshold set to ${pct}%.` };
+        }
+        if (arg1 === 'warn' && arg2) {
+            const pct = parseInt(arg2, 10);
+            if (isNaN(pct) || pct < 5 || pct > 95) {
+                return { type: 'message', message: 'Invalid warning threshold. Use a value between 5 and 95.' };
+            }
+            ctx.settingsMgr?.update({ auto_compact: { ...s.auto_compact, warn_threshold: pct } });
+            return { type: 'message', message: `Warning threshold set to ${pct}%.` };
+        }
+        if (arg1 === 'pricing') {
+            if (arg2 === 'on') {
+                ctx.settingsMgr?.update({ pricing_tier_warn: 'on' });
+                return { type: 'message', message: 'Pricing tier warnings enabled.' };
+            }
+            if (arg2 === 'off') {
+                ctx.settingsMgr?.update({ pricing_tier_warn: 'off' });
+                return { type: 'message', message: 'Pricing tier warnings disabled.' };
+            }
+            return { type: 'message', message: 'Usage: /context auto pricing on/off' };
+        }
+        return { type: 'message', message: 'Usage: /context auto [on|off|threshold N|warn N|pricing on/off]\nRun "/context auto" without arguments to see current settings.' };
+    }
     // Default: context window visual (unchanged behavior)
-    const input = ctx.inputTokens ?? 0;
-    const output = ctx.outputTokens ?? 0;
+    const input = ctx.contextWindowInputTokens ?? ctx.inputTokens ?? 0;
+    const output = ctx.contextWindowOutputTokens ?? ctx.outputTokens ?? 0;
     const model = ctx.model || 'unknown';
-    const windowSize = ctx.settings.MODEL_CONTEXT_WINDOW ?? ctx.contextWindowSize ?? 200_000;
+    const windowSize = ctx.settings.providers?.[ctx.settings.current_provider]?.model_context_window ?? ctx.contextWindowSize ?? 200_000;
     const pct = input > 0 ? Math.min(100, Math.round((input / windowSize) * 100)) : 0;
     const filled = Math.round((pct / 100) * 24);
     const bar = '█'.repeat(filled) + '░'.repeat(24 - filled);
@@ -846,7 +1361,7 @@ function handleProvider(args) {
     if (!args) {
         return {
             type: 'message',
-            message: `Usage: /provider <name>\nProviders: ${validProviders.join(', ')}\n\nCurrent settings:\n  anthropic: MODEL_API_KEY, MODEL_URL\n  openai: OPENAI_API_KEY, OPENAI_URL\n  google: GOOGLE_API_KEY, GOOGLE_URL\n  local: MODEL_URL, MODEL_API_KEY\n  ollama: MODEL_URL, MODEL_API_KEY\n  openrouter: OPENROUTER_URL, OPENROUTER_API_KEY`,
+            message: `Usage: /provider <name>\nProviders: ${validProviders.join(', ')}\n\nCurrent settings:\n  anthropic: providers.anthropic.api_key, providers.anthropic.url\n  openai: providers.openai.api_key, providers.openai.url\n  google: providers.google.api_key, providers.google.url\n  local: providers.local.url, providers.local.api_key\n  ollama: providers.ollama.url, providers.ollama.api_key\n  openrouter: providers.openrouter.api_key, providers.openrouter.url`,
         };
     }
     const provider = args.toLowerCase();
@@ -865,17 +1380,18 @@ function handleHeartbeat(args, ctx) {
     switch (sub) {
         case 'status':
         case '': {
-            const active = ctx.settings.HEARTBEAT === 'on';
-            const intraday = ctx.settings.HEARTBEAT_INTRADAY ?? '';
-            const daily = ctx.settings.HEARTBEAT_DAILY ?? '6:00';
-            const weekly = ctx.settings.HEARTBEAT_WEEKLY ?? 'monday@6:00';
-            const monthly = ctx.settings.HEARTBEAT_MONTHLY ?? '1@6:00';
+            const active = ctx.settings.heartbeat?.schedule === 'on';
+            const intraday = ctx.settings.heartbeat?.intraday ?? '';
+            const daily = ctx.settings.heartbeat?.daily ?? '6:00';
+            const weekly = ctx.settings.heartbeat?.weekly ?? 'monday@6:00';
+            const monthly = ctx.settings.heartbeat?.monthly ?? '1@6:00';
+            const dreaming = ctx.settings.heartbeat?.dreaming ?? '2:00';
             const intradayDisplay = intraday ? intraday.split(',').map((s) => s.trim()).join(', ') : '(not set)';
-            const picked = pickNextSchedule({ HEARTBEAT_INTRADAY: intraday, HEARTBEAT_DAILY: daily, HEARTBEAT_WEEKLY: weekly, HEARTBEAT_MONTHLY: monthly });
+            const picked = pickNextSchedule({ HEARTBEAT_INTRADAY: intraday, HEARTBEAT_DAILY: daily, HEARTBEAT_WEEKLY: weekly, HEARTBEAT_MONTHLY: monthly, HEARTBEAT_DREAMING: dreaming });
             const activeSchedule = picked ? `${picked.type} (${picked.value})` : '(none configured)';
             return {
                 type: 'message',
-                message: `Heartbeat cycle:\n  Enabled: ${active ? 'yes' : 'no'}\n  Active schedule: ${activeSchedule}\n\n  Intraday: ${intradayDisplay}\n  Daily:   ${daily}\n  Weekly:  ${weekly}\n  Monthly: ${monthly}\n\nUsage:\n  /heartbeat                        — show status\n  /heartbeat enable                 — turn on\n  /heartbeat disable                — turn off\n  /heartbeat intraday <H:MM,...>    — set intra-day times (e.g. 8:10,10:10,14:20)\n  /heartbeat daily <H:MM>           — set daily time (24h)\n  /heartbeat weekly <day@H:MM>\n  /heartbeat monthly <D@H:MM>\n  /heartbeat now                    — run immediately`,
+                message: `Heartbeat cycle:\n  Enabled        : ${active ? 'yes' : 'no'}\n  Active schedule: ${activeSchedule}\n\n  Intraday: ${intradayDisplay}\n  Daily   : ${daily}\n  Weekly  : ${weekly}\n  Monthly : ${monthly}\n  Dreaming: ${dreaming}\n\nUsage:\n  /heartbeat                        — show status\n  /heartbeat enable                 — turn on\n  /heartbeat disable                — turn off\n  /heartbeat intraday <H:MM,...>    — set intra-day times (e.g. 8:10,10:10,14:20)\n  /heartbeat daily <H:MM>           — set daily time (24h)\n  /heartbeat weekly <day@H:MM>\n  /heartbeat monthly <D@H:MM>\n  /heartbeat dreaming <H:MM>        — set dreaming time (24h)\n  /heartbeat now                    — run immediately`,
             };
         }
         case 'enable': {
@@ -886,7 +1402,7 @@ function handleHeartbeat(args, ctx) {
         }
         case 'intraday': {
             if (!rest) {
-                const current = ctx.settings.HEARTBEAT_INTRADAY ?? '';
+                const current = ctx.settings.heartbeat?.intraday ?? '';
                 return {
                     type: 'message',
                     message: `Usage: /heartbeat intraday <H:MM,...>\nExample: /heartbeat intraday 8:10,10:10,14:20,16:20\nCurrent: ${current || '(not set)'}`,
@@ -907,14 +1423,14 @@ function handleHeartbeat(args, ctx) {
             const value = tokens.join(',');
             return {
                 type: 'notification',
-                notification: { type: 'heartbeat-set', key: 'HEARTBEAT_INTRADAY', value },
+                notification: { type: 'heartbeat-set', key: 'heartbeat.intraday', value },
             };
         }
         case 'daily': {
             if (!rest) {
                 return {
                     type: 'message',
-                    message: `Usage: /heartbeat daily <H:MM>\nExample: /heartbeat daily 6:00\nCurrent: ${ctx.settings.HEARTBEAT_DAILY ?? '6:00'}`,
+                    message: `Usage: /heartbeat daily <H:MM>\nExample: /heartbeat daily 6:00\nCurrent: ${ctx.settings.heartbeat?.daily ?? '6:00'}`,
                 };
             }
             if (!/^\d{1,2}:\d{2}$/.test(rest)) {
@@ -928,14 +1444,14 @@ function handleHeartbeat(args, ctx) {
             }
             return {
                 type: 'notification',
-                notification: { type: 'heartbeat-set', key: 'HEARTBEAT_DAILY', value: rest },
+                notification: { type: 'heartbeat-set', key: 'heartbeat.daily', value: rest },
             };
         }
         case 'weekly': {
             if (!rest) {
                 return {
                     type: 'message',
-                    message: `Usage: /heartbeat weekly <day@H:MM>\nExample: /heartbeat weekly monday@6:00\nCurrent: ${ctx.settings.HEARTBEAT_WEEKLY ?? 'monday@6:00'}`,
+                    message: `Usage: /heartbeat weekly <day@H:MM>\nExample: /heartbeat weekly monday@6:00\nCurrent: ${ctx.settings.heartbeat?.weekly ?? 'monday@6:00'}`,
                 };
             }
             const atIdx = rest.indexOf('@');
@@ -952,14 +1468,14 @@ function handleHeartbeat(args, ctx) {
             }
             return {
                 type: 'notification',
-                notification: { type: 'heartbeat-set', key: 'HEARTBEAT_WEEKLY', value: rest },
+                notification: { type: 'heartbeat-set', key: 'heartbeat.weekly', value: rest },
             };
         }
         case 'monthly': {
             if (!rest) {
                 return {
                     type: 'message',
-                    message: `Usage: /heartbeat monthly <D@H:MM>\nExample: /heartbeat monthly 1@6:00\nCurrent: ${ctx.settings.HEARTBEAT_MONTHLY ?? '1@6:00'}`,
+                    message: `Usage: /heartbeat monthly <D@H:MM>\nExample: /heartbeat monthly 1@6:00\nCurrent: ${ctx.settings.heartbeat?.monthly ?? '1@6:00'}`,
                 };
             }
             const atIdx = rest.indexOf('@');
@@ -975,7 +1491,28 @@ function handleHeartbeat(args, ctx) {
             }
             return {
                 type: 'notification',
-                notification: { type: 'heartbeat-set', key: 'HEARTBEAT_MONTHLY', value: rest },
+                notification: { type: 'heartbeat-set', key: 'heartbeat.monthly', value: rest },
+            };
+        }
+        case 'dreaming': {
+            if (!rest) {
+                return {
+                    type: 'message',
+                    message: `Usage: /heartbeat dreaming <H:MM>\nExample: /heartbeat dreaming 2:00\nCurrent: ${ctx.settings.heartbeat?.dreaming ?? '2:00'}`,
+                };
+            }
+            if (!/^\d{1,2}:\d{2}$/.test(rest)) {
+                return { type: 'message', message: `Invalid time: "${rest}". Use H:MM (e.g., 2:00, 14:30).` };
+            }
+            const [hStr, mStr] = rest.split(':');
+            const h = parseInt(hStr ?? '0', 10);
+            const m = parseInt(mStr ?? '0', 10);
+            if (isNaN(h) || isNaN(m) || h < 0 || h > 23 || m < 0 || m > 59) {
+                return { type: 'message', message: `Invalid time: "${rest}". Hour 0-23, minute 0-59.` };
+            }
+            return {
+                type: 'notification',
+                notification: { type: 'heartbeat-set', key: 'heartbeat.dreaming', value: rest },
             };
         }
         case 'now': {
@@ -984,7 +1521,7 @@ function handleHeartbeat(args, ctx) {
         default:
             return {
                 type: 'message',
-                message: `Unknown heartbeat action: "${sub}". Use: status, enable, disable, intraday, daily, weekly, monthly, now`,
+                message: `Unknown heartbeat action: "${sub}". Use: status, enable, disable, intraday, daily, weekly, monthly, dreaming, now`,
             };
     }
 }
@@ -997,7 +1534,7 @@ function handleSnapshots(ctx) {
     list.forEach((s, i) => {
         const dt = new Date(s.timestamp);
         const timeStr = dt.toLocaleString();
-        lines.push(`  ${i}) ${timeStr} — ${s.sha.slice(0, 7)} (${s.label}, ${s.changedFiles} file${s.changedFiles === 1 ? '' : 's'})`);
+        lines.push(`  ${i})-${timeStr} — ${s.sha.slice(0, 7)} (${s.label}, ${s.changedFiles} file${s.changedFiles === 1 ? '' : 's'})`);
     });
     lines.push('\nUse /revert <index> to restore a snapshot.');
     return { type: 'message', message: lines.join('\n') };
@@ -1029,4 +1566,65 @@ async function handleRevert(args, ctx) {
     }
     return { type: 'message', message: result.error ?? 'Revert failed.' };
 }
+function handleTask(args, ctx) {
+    // /task creates auto-mode scheduled tasks (LLM executes at given time).
+    // Uses unified TaskManager.
+    const parts = args.trim().split(/\s+/);
+    const action = parts[0]?.toLowerCase();
+    const rest = parts.slice(1).join(' ').trim();
+    if (!ctx.taskManager) {
+        return { type: 'message', message: 'Task service not available. Please restart the application.' };
+    }
+    switch (action) {
+        case 'create': {
+            if (!rest) {
+                return {
+                    type: 'message',
+                    message: 'Usage: /task create <instruction at time>\nExample:\n  /task create "at 7:55 make a report about AI models"\nOr use /todo agent add "..." for the new unified format.',
+                };
+            }
+            let { parseReminderTime } = {};
+            try {
+                Object.assign(require('../../core/src/reminder-parser.js'), { parseReminderTime });
+            }
+            catch { /* not available */ }
+            if (!parseReminderTime) {
+                return { type: 'message', message: `Could not parse time from: "${rest}".\nTry: /todo agent add "at 7:55 do something"` };
+            }
+            const parsed = parseReminderTime(rest);
+            if (!parsed) {
+                return { type: 'message', message: `Could not parse time from: "${rest}".\nUse /todo agent add "instruction at time"` };
+            }
+            ctx.taskManager.load();
+            const task = ctx.taskManager.create({ title: parsed.message, mode: 'agent', scope: 'personal', scheduled_at: parsed.scheduledAt });
+            return { type: 'message', message: `Task scheduled:\nTime: ${new Date(task.scheduled_at).toLocaleString()}\nInstruction: ${task.title}\nID: ${task.id}` };
+        }
+        case 'list': {
+            ctx.taskManager.load();
+            const tasks = ctx.taskManager.list({ mode: 'agent' });
+            if (!tasks.length)
+                return { type: 'message', message: 'No scheduled tasks.\nUse /todo agent add "..." to create one.' };
+            const lines = [`Tasks (${tasks.length}):`];
+            for (const t of tasks) {
+                const timeStr = t.scheduled_at ? new Date(t.scheduled_at).toLocaleString() : '—';
+                const statusLabel = t.status === 'pending' ? 'PENDING' : t.status === 'executing' ? 'RUNNING' : t.status.toUpperCase();
+                lines.push(`  [${statusLabel}] ${t.title}\n    Time: ${timeStr}\n    ID: ${t.id.slice(0, 8)}`);
+            }
+            return { type: 'message', message: lines.join('\n') };
+        }
+        case 'delete': {
+            if (!rest)
+                return { type: 'message', message: 'Usage: /task delete <id>' };
+            const result = ctx.taskManager.cancelTask(rest);
+            if (result)
+                return { type: 'message', message: 'Task cancelled.' };
+            return { type: 'message', message: `No task found with ID: ${rest}` };
+        }
+        default:
+            return {
+                type: 'message',
+                message: 'Usage: /task <create|list|delete>\n  create <instruction at time>  — Schedule a task\n  list                          — List scheduled tasks\n  delete <id>                   — Cancel a task\nOr use /todo auto add "..." for the new unified format.',
+            };
+    }
+}
 //# sourceMappingURL=slash-commands.js.map