@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/dist/gateway-service.js

@@ -1,25 +1,28 @@
+import { spawnSync } from 'node:child_process';
 import { CronExpressionParser } from 'cron-parser';
-import { spawnSync } from 'child_process';
-import { APP_VERSION, DISCORD_COMMANDS_ONLY, DISCORD_RESPOND_TO_ALL_MESSAGES, HYBRIDAI_CHATBOT_ID, HYBRIDAI_ENABLE_RAG, HYBRIDAI_MODEL, HYBRIDAI_MODELS, PROACTIVE_AUTO_RETRY_BASE_DELAY_MS, PROACTIVE_AUTO_RETRY_ENABLED, PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS, PROACTIVE_AUTO_RETRY_MAX_DELAY_MS, PROACTIVE_DELEGATION_MAX_DEPTH, PROACTIVE_DELEGATION_MAX_PER_TURN, PROACTIVE_RALPH_MAX_ITERATIONS, } from './config.js';
 import { runAgent } from './agent.js';
-import { getActiveContainerCount, stopSessionContainer } from './container-runner.js';
-import { clearSessionHistory, createTask, deleteTask, getAllSessions, getConversationHistory, getOrCreateSession, getQueuedProactiveMessageCount, getRecentStructuredAuditForSession, getSessionCount, getTasksForSession, logAudit, storeMessage, toggleTask, updateSessionChatbot, updateSessionModel, updateSessionRag, } from './db.js';
-import { emitToolExecutionAuditEvents, makeAuditRunId, recordAuditEvent } from './audit-events.js';
+import { emitToolExecutionAuditEvents, makeAuditRunId, recordAuditEvent, } from './audit-events.js';
+import { APP_VERSION, DISCORD_COMMANDS_ONLY, DISCORD_FREE_RESPONSE_CHANNELS, DISCORD_GROUP_POLICY, DISCORD_GUILDS, DISCORD_RESPOND_TO_ALL_MESSAGES, HYBRIDAI_CHATBOT_ID, HYBRIDAI_ENABLE_RAG, HYBRIDAI_MODEL, HYBRIDAI_MODELS, PROACTIVE_AUTO_RETRY_BASE_DELAY_MS, PROACTIVE_AUTO_RETRY_ENABLED, PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS, PROACTIVE_AUTO_RETRY_MAX_DELAY_MS, PROACTIVE_DELEGATION_MAX_DEPTH, PROACTIVE_DELEGATION_MAX_PER_TURN, PROACTIVE_RALPH_MAX_ITERATIONS, } from './config.js';
+import { getActiveContainerCount, stopSessionContainer, } from './container-runner.js';
+import { buildConversationContext } from './conversation.js';
+import { createTask, deleteTask, getAllSessions, getQueuedProactiveMessageCount, getRecentStructuredAuditForSession, getSessionCount, getTasksForSession, getUsageTotals, listUsageByAgent, listUsageByModel, logAudit, pauseTask, recordUsageEvent, resumeTask, updateSessionChatbot, updateSessionModel, updateSessionRag, } from './db.js';
+import { delegationQueueStatus, enqueueDelegation, } from './delegation-manager.js';
+import { renderGatewayCommand, } from './gateway-types.js';
 import { fetchHybridAIBots } from './hybridai-bots.js';
+import { resolveModelContextWindowFallback, } from './hybridai-models.js';
 import { logger } from './logger.js';
+import { memoryService } from './memory-service.js';
 import { getObservabilityIngestState } from './observability-ingest.js';
-import { rearmScheduler } from './scheduler.js';
+import { updateRuntimeConfig } from './runtime-config.js';
+import { runIsolatedScheduledTask } from './scheduled-task-runner.js';
+import { getSchedulerStatus, rearmScheduler } from './scheduler.js';
+import { exportSessionSnapshotJsonl } from './session-export.js';
 import { maybeCompactSession } from './session-maintenance.js';
 import { appendSessionTranscript } from './session-transcripts.js';
 import { processSideEffects } from './side-effects.js';
 import { expandSkillInvocation } from './skills.js';
-import { renderGatewayCommand, } from './gateway-types.js';
+import { estimateTokenCountFromMessages, estimateTokenCountFromText, } from './token-efficiency.js';
 import { ensureBootstrapFiles } from './workspace.js';
-import { buildConversationContext } from './conversation.js';
-import { runIsolatedScheduledTask } from './scheduled-task-runner.js';
-import { delegationQueueStatus, enqueueDelegation } from './delegation-manager.js';
-import { estimateTokenCountFromMessages, estimateTokenCountFromText } from './token-efficiency.js';
-import { updateRuntimeConfig } from './runtime-config.js';
 const BOT_CACHE_TTL = 300_000; // 5 minutes
 const MAX_HISTORY_MESSAGES = 40;
 const BASE_SUBAGENT_ALLOWED_TOOLS = [
@@ -37,6 +40,7 @@ const BASE_SUBAGENT_ALLOWED_TOOLS = [
     'browser_snapshot',
     'browser_click',
     'browser_type',
+    'browser_upload',
     'browser_press',
     'browser_scroll',
     'browser_back',
@@ -50,10 +54,15 @@ const BASE_SUBAGENT_ALLOWED_TOOLS = [
     'browser_network',
     'browser_close',
 ];
-const ORCHESTRATOR_SUBAGENT_ALLOWED_TOOLS = [...BASE_SUBAGENT_ALLOWED_TOOLS, 'delegate'];
+const ORCHESTRATOR_SUBAGENT_ALLOWED_TOOLS = [
+    ...BASE_SUBAGENT_ALLOWED_TOOLS,
+    'delegate',
+];
 const MAX_DELEGATION_TASKS = 6;
 const MAX_DELEGATION_USER_CHARS = 500;
 const MAX_RALPH_ITERATIONS = 64;
+const DISCORD_CHANNEL_MODE_VALUES = new Set(['off', 'mention', 'free']);
+const DISCORD_GROUP_POLICY_VALUES = new Set(['open', 'allowlist', 'disabled']);
 const IMAGE_QUESTION_RE = /(what(?:'s| is)? on (?:the )?(?:image|picture|photo|screenshot)|describe (?:this|the) (?:image|picture|photo)|image|picture|photo|screenshot|ocr|diagram|chart|grafik|bild|foto|was steht|was ist auf dem bild)/i;
 const BROWSER_TAB_RE = /(browser|tab|current tab|web page|website|seite im browser|aktuellen tab)/i;
 const TRANSIENT_DELEGATION_ERROR_PATTERNS = [
@@ -106,7 +115,9 @@ function normalizeMediaContextItems(raw) {
     for (const item of raw) {
         if (!item || typeof item !== 'object')
             continue;
-        const path = typeof item.path === 'string' && item.path.trim() ? item.path.trim() : null;
+        const path = typeof item.path === 'string' && item.path.trim()
+            ? item.path.trim()
+            : null;
         const url = typeof item.url === 'string' ? item.url.trim() : '';
         const originalUrl = typeof item.originalUrl === 'string' ? item.originalUrl.trim() : '';
         const filename = typeof item.filename === 'string' ? item.filename.trim() : '';
@@ -132,7 +143,9 @@ function normalizeMediaContextItems(raw) {
 function buildMediaPromptContext(media) {
     if (media.length === 0)
         return '';
-    const mediaPaths = media.map((item) => item.path).filter((path) => Boolean(path));
+    const mediaPaths = media
+        .map((item) => item.path)
+        .filter((path) => Boolean(path));
     const mediaUrls = media.map((item) => item.url);
     const mediaTypes = media.map((item) => item.mimeType || 'unknown');
     const payload = media.map((item, index) => ({
@@ -237,7 +250,9 @@ function formatRelativeTime(raw) {
     return `${Math.max(1, Math.floor(deltaMs / 86_400_000))}d ago`;
 }
 function numberFromUnknown(value) {
-    if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value))
+    if (typeof value !== 'number' ||
+        Number.isNaN(value) ||
+        !Number.isFinite(value))
         return null;
     return value;
 }
@@ -265,7 +280,9 @@ function formatCompactNumber(value) {
         return 'n/a';
     const abs = Math.abs(value);
     if (abs >= 1_000_000) {
-        const scaled = abs >= 10_000_000 ? (value / 1_000_000).toFixed(0) : (value / 1_000_000).toFixed(1);
+        const scaled = abs >= 10_000_000
+            ? (value / 1_000_000).toFixed(0)
+            : (value / 1_000_000).toFixed(1);
         return `${scaled.replace(/\.0$/, '')}M`;
     }
     if (abs >= 1_000) {
@@ -279,17 +296,111 @@ function formatPercent(value) {
         return 'n/a';
     return `${Math.max(0, Math.min(100, Math.round(value)))}%`;
 }
+function formatUsd(value) {
+    if (value == null || Number.isNaN(value) || !Number.isFinite(value)) {
+        return 'n/a';
+    }
+    if (value <= 0)
+        return '$0.0000';
+    if (value >= 1)
+        return `$${value.toFixed(2)}`;
+    if (value >= 0.01)
+        return `$${value.toFixed(4)}`;
+    return `$${value.toFixed(6)}`;
+}
+function resolveSessionAgentId(session) {
+    const sessionAgent = session.chatbot_id?.trim();
+    if (sessionAgent)
+        return sessionAgent;
+    const defaultAgent = HYBRIDAI_CHATBOT_ID?.trim();
+    if (defaultAgent)
+        return defaultAgent;
+    return null;
+}
+function extractUsageCostUsd(tokenUsage) {
+    if (!tokenUsage)
+        return 0;
+    const costCarrier = tokenUsage;
+    const value = firstNumber([
+        costCarrier.costUsd,
+        costCarrier.costUSD,
+        costCarrier.cost_usd,
+        costCarrier.estimatedCostUsd,
+        costCarrier.estimated_cost_usd,
+    ]);
+    if (value == null)
+        return 0;
+    return Math.max(0, value);
+}
+function formatCanonicalContextPrompt(params) {
+    const sections = [];
+    const summary = (params.summary || '').trim();
+    if (summary) {
+        sections.push(['### Canonical Session Summary', summary].join('\n'));
+    }
+    if (params.recentMessages.length > 0) {
+        const lines = params.recentMessages.slice(-6).map((entry) => {
+            const role = (entry.role || 'user').trim().toLowerCase();
+            const who = role === 'assistant' ? 'Assistant' : 'User';
+            const from = entry.channel_id && entry.channel_id.trim()
+                ? `${entry.channel_id.trim()} (${entry.session_id})`
+                : entry.session_id;
+            const compact = entry.content.replace(/\s+/g, ' ').trim();
+            const short = compact.length > 180 ? `${compact.slice(0, 180)}...` : compact;
+            return `- ${who} [${from}]: ${short}`;
+        });
+        sections.push([
+            '### Cross-Channel Recall',
+            'Recent context from other sessions/channels for this user:',
+            ...lines,
+        ].join('\n'));
+    }
+    const merged = sections.join('\n\n').trim();
+    return merged || null;
+}
 function resolveActivationModeLabel() {
     if (DISCORD_COMMANDS_ONLY)
         return 'commands-only';
+    if (DISCORD_GROUP_POLICY === 'disabled')
+        return 'disabled';
+    if (DISCORD_GROUP_POLICY === 'allowlist')
+        return 'allowlist';
+    if (DISCORD_FREE_RESPONSE_CHANNELS.length > 0)
+        return `mention + ${DISCORD_FREE_RESPONSE_CHANNELS.length} free channel(s)`;
     if (DISCORD_RESPOND_TO_ALL_MESSAGES)
         return 'all messages';
     return 'mention';
 }
-function readSessionStatusSnapshot(sessionId) {
+function resolveGuildChannelMode(guildId, channelId) {
+    if (!guildId)
+        return 'free';
+    if (DISCORD_GROUP_POLICY === 'disabled')
+        return 'off';
+    const guild = DISCORD_GUILDS[guildId];
+    const explicit = guild?.channels[channelId]?.mode;
+    if (DISCORD_GROUP_POLICY === 'allowlist') {
+        return explicit ?? 'off';
+    }
+    if (explicit === 'off' || explicit === 'mention' || explicit === 'free') {
+        return explicit;
+    }
+    if (DISCORD_FREE_RESPONSE_CHANNELS.includes(channelId))
+        return 'free';
+    if (guild) {
+        const defaultMode = guild.defaultMode;
+        if (defaultMode === 'off' ||
+            defaultMode === 'mention' ||
+            defaultMode === 'free') {
+            return defaultMode;
+        }
+    }
+    if (DISCORD_RESPOND_TO_ALL_MESSAGES)
+        return 'free';
+    return 'mention';
+}
+function readSessionStatusSnapshot(sessionId, options) {
     const entries = getRecentStructuredAuditForSession(sessionId, 160);
     let usagePayload = null;
-    let contextPayload = null;
     for (const entry of entries) {
         const payload = parseAuditPayload(entry);
         if (!payload)
@@ -298,10 +409,7 @@ function readSessionStatusSnapshot(sessionId) {
         if (!usagePayload && payloadType === 'model.usage') {
             usagePayload = payload;
         }
-        else if (!contextPayload && payloadType === 'context.optimization') {
-            contextPayload = payload;
-        }
-        if (usagePayload && contextPayload)
+        if (usagePayload)
             break;
     }
     const promptTokens = firstNumber([
@@ -317,25 +425,58 @@ function readSessionStatusSnapshot(sessionId) {
     const cacheReadTokens = firstNumber([
         usagePayload?.cacheReadTokens,
         usagePayload?.cacheReadInputTokens,
+        usagePayload?.apiCacheReadTokens,
+        usagePayload?.cacheRead,
+        usagePayload?.cache_read,
+        usagePayload?.cache_read_tokens,
+        usagePayload?.cache_read_input_tokens,
+        usagePayload?.cached_tokens,
+        usagePayload?.prompt_tokens_details
+            ?.cached_tokens,
     ]);
     const cacheWriteTokens = firstNumber([
         usagePayload?.cacheWriteTokens,
         usagePayload?.cacheWriteInputTokens,
+        usagePayload?.apiCacheWriteTokens,
+        usagePayload?.cacheWrite,
+        usagePayload?.cache_write,
+        usagePayload?.cache_write_tokens,
+        usagePayload?.cache_write_input_tokens,
+        usagePayload?.cache_creation_input_tokens,
     ]);
     const cacheRead = Math.max(0, cacheReadTokens || 0);
     const cacheWrite = Math.max(0, cacheWriteTokens || 0);
     const cacheTotal = cacheRead + cacheWrite;
     const cacheHitPercent = cacheTotal > 0 ? (cacheRead / cacheTotal) * 100 : null;
-    const contextUsedTokens = firstNumber([contextPayload?.historyEstimatedTokens]);
-    const contextBudgetTokens = (() => {
-        const maxChars = firstNumber([contextPayload?.historyMaxChars]);
-        if (maxChars == null || maxChars <= 0)
-            return null;
-        return Math.max(1, Math.round(maxChars / 4));
-    })();
-    const contextUsagePercent = (contextUsedTokens != null
-        && contextBudgetTokens != null
-        && contextBudgetTokens > 0)
+    const contextUsedTokens = firstNumber([
+        usagePayload?.contextTokens,
+        usagePayload?.context_tokens,
+        usagePayload?.tokensInContext,
+        usagePayload?.tokens_in_context,
+        usagePayload?.promptTokens,
+        usagePayload?.apiPromptTokens,
+        usagePayload?.estimatedPromptTokens,
+    ]);
+    const contextBudgetTokens = firstNumber([
+        usagePayload?.contextWindowTokens,
+        usagePayload?.context_window_tokens,
+        usagePayload?.modelContextWindowTokens,
+        usagePayload?.model_context_window_tokens,
+        usagePayload?.modelContextWindow,
+        usagePayload?.model_context_window,
+        usagePayload?.maxContextTokens,
+        usagePayload?.max_context_tokens,
+        usagePayload?.contextWindow,
+        usagePayload?.context_window,
+        usagePayload?.contextLength,
+        usagePayload?.context_length,
+        usagePayload?.maxContextSize,
+        usagePayload?.max_context_size,
+        options?.modelContextWindowTokens,
+    ]);
+    const contextUsagePercent = contextUsedTokens != null &&
+        contextBudgetTokens != null &&
+        contextBudgetTokens > 0
         ? (contextUsedTokens / contextBudgetTokens) * 100
         : null;
     return {
@@ -387,17 +528,53 @@ function isVersionOnlyQuestion(raw) {
     if (detailedRuntimeTokens.some((token) => text.includes(token)))
         return false;
     const words = text.split(' ').filter(Boolean);
-    if (words.length > 8
-        && !text.includes('welche version')
-        && !text.includes('what version')
-        && !text.includes('which version')) {
+    if (words.length > 8 &&
+        !text.includes('welche version') &&
+        !text.includes('what version') &&
+        !text.includes('which version')) {
         return false;
     }
     return true;
 }
 function recordSuccessfulTurn(opts) {
-    storeMessage(opts.sessionId, opts.userId, opts.username, 'user', opts.userContent);
-    storeMessage(opts.sessionId, 'assistant', null, 'assistant', opts.resultText);
+    memoryService.storeTurn({
+        sessionId: opts.sessionId,
+        user: {
+            userId: opts.userId,
+            username: opts.username,
+            content: opts.userContent,
+        },
+        assistant: {
+            userId: 'assistant',
+            username: null,
+            content: opts.resultText,
+        },
+    });
+    try {
+        if (opts.userId.trim()) {
+            memoryService.appendCanonicalMessages({
+                agentId: opts.agentId,
+                userId: opts.userId,
+                newMessages: [
+                    {
+                        role: 'user',
+                        content: opts.userContent,
+                        sessionId: opts.sessionId,
+                        channelId: opts.channelId,
+                    },
+                    {
+                        role: 'assistant',
+                        content: opts.resultText,
+                        sessionId: opts.sessionId,
+                        channelId: opts.channelId,
+                    },
+                ],
+            });
+        }
+    }
+    catch (err) {
+        logger.debug({ sessionId: opts.sessionId, userId: opts.userId, err }, 'Failed to append canonical session memory');
+    }
     appendSessionTranscript(opts.agentId, {
         sessionId: opts.sessionId,
         channelId: opts.channelId,
@@ -484,13 +661,21 @@ function buildTokenUsageAuditPayload(messages, resultText, tokenUsage) {
     const fallbackEstimatedCompletionTokens = estimateTokenCountFromText(resultText || '');
     const estimatedPromptTokens = tokenUsage?.estimatedPromptTokens || fallbackEstimatedPromptTokens;
     const estimatedCompletionTokens = tokenUsage?.estimatedCompletionTokens || fallbackEstimatedCompletionTokens;
-    const estimatedTotalTokens = tokenUsage?.estimatedTotalTokens || (estimatedPromptTokens + estimatedCompletionTokens);
+    const estimatedTotalTokens = tokenUsage?.estimatedTotalTokens ||
+        estimatedPromptTokens + estimatedCompletionTokens;
     const apiUsageAvailable = tokenUsage?.apiUsageAvailable === true;
     const apiPromptTokens = tokenUsage?.apiPromptTokens || 0;
     const apiCompletionTokens = tokenUsage?.apiCompletionTokens || 0;
-    const apiTotalTokens = tokenUsage?.apiTotalTokens || (apiPromptTokens + apiCompletionTokens);
-    const promptTokens = apiUsageAvailable ? apiPromptTokens : estimatedPromptTokens;
-    const completionTokens = apiUsageAvailable ? apiCompletionTokens : estimatedCompletionTokens;
+    const apiTotalTokens = tokenUsage?.apiTotalTokens || apiPromptTokens + apiCompletionTokens;
+    const apiCacheUsageAvailable = tokenUsage?.apiCacheUsageAvailable === true;
+    const apiCacheReadTokens = tokenUsage?.apiCacheReadTokens || 0;
+    const apiCacheWriteTokens = tokenUsage?.apiCacheWriteTokens || 0;
+    const promptTokens = apiUsageAvailable
+        ? apiPromptTokens
+        : estimatedPromptTokens;
+    const completionTokens = apiUsageAvailable
+        ? apiCompletionTokens
+        : estimatedCompletionTokens;
     const totalTokens = apiUsageAvailable ? apiTotalTokens : estimatedTotalTokens;
     return {
         modelCalls: tokenUsage ? Math.max(1, tokenUsage.modelCalls) : 0,
@@ -506,6 +691,17 @@ function buildTokenUsageAuditPayload(messages, resultText, tokenUsage) {
         apiPromptTokens,
         apiCompletionTokens,
         apiTotalTokens,
+        ...(apiCacheUsageAvailable
+            ? {
+                apiCacheUsageAvailable,
+                apiCacheReadTokens,
+                apiCacheWriteTokens,
+                cacheReadTokens: apiCacheReadTokens,
+                cacheReadInputTokens: apiCacheReadTokens,
+                cacheWriteTokens: apiCacheWriteTokens,
+                cacheWriteInputTokens: apiCacheWriteTokens,
+            }
+            : {}),
     };
 }
 export function getGatewayStatus() {
@@ -520,10 +716,15 @@ export function getGatewayStatus() {
         ragDefault: HYBRIDAI_ENABLE_RAG,
         timestamp: new Date().toISOString(),
         observability: getObservabilityIngestState(),
+        scheduler: {
+            jobs: getSchedulerStatus(),
+        },
     };
 }
 export function getGatewayHistory(sessionId, limit = MAX_HISTORY_MESSAGES) {
-    return getConversationHistory(sessionId, Math.max(1, Math.min(limit, 200))).reverse();
+    return memoryService
+        .getConversationHistory(sessionId, Math.max(1, Math.min(limit, 200)))
+        .reverse();
 }
 function extractDelegationDepth(sessionId) {
     const match = sessionId.match(/^delegate:d(\d+):/);
@@ -533,7 +734,9 @@ function extractDelegationDepth(sessionId) {
     return Number.isFinite(parsed) ? parsed : 0;
 }
 function nextDelegationSessionId(parentSessionId, nextDepth) {
-    const safeParent = parentSessionId.replace(/[^a-zA-Z0-9:_-]/g, '-').slice(0, 48);
+    const safeParent = parentSessionId
+        .replace(/[^a-zA-Z0-9:_-]/g, '-')
+        .slice(0, 48);
     const nonce = Math.random().toString(36).slice(2, 8);
     return `delegate:d${nextDepth}:${safeParent}:${Date.now()}:${nonce}`;
 }
@@ -602,7 +805,9 @@ function classifyDelegationError(errorText) {
     return 'unknown';
 }
 function inferDelegationStatus(errorText) {
-    return /timeout|timed out|deadline exceeded/i.test(errorText) ? 'timeout' : 'failed';
+    return /timeout|timed out|deadline exceeded/i.test(errorText)
+        ? 'timeout'
+        : 'failed';
 }
 function normalizeDelegationTask(raw, fallbackModel) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
@@ -661,7 +866,9 @@ function normalizeDelegationEffect(effect, fallbackModel) {
         return { error: `${mode} delegation requires at least one task` };
     }
     if (sourceTasks.length > MAX_DELEGATION_TASKS) {
-        return { error: `${mode} delegation exceeds max tasks (${MAX_DELEGATION_TASKS})` };
+        return {
+            error: `${mode} delegation exceeds max tasks (${MAX_DELEGATION_TASKS})`,
+        };
     }
     const tasks = [];
     for (let i = 0; i < sourceTasks.length; i++) {
@@ -700,7 +907,9 @@ async function runDelegationTaskWithRetry(input) {
     const { parentSessionId, childDepth, channelId, chatbotId, enableRag, agentId, mode, task, } = input;
     const allowedTools = resolveSubagentAllowedTools(childDepth);
     const canDelegate = allowedTools.includes('delegate');
-    const maxAttempts = PROACTIVE_AUTO_RETRY_ENABLED ? PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS : 1;
+    const maxAttempts = PROACTIVE_AUTO_RETRY_ENABLED
+        ? PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS
+        : 1;
     let attempt = 0;
     let delayMs = PROACTIVE_AUTO_RETRY_BASE_DELAY_MS;
     let lastError = 'Delegation failed with unknown error';
@@ -716,7 +925,14 @@ async function runDelegationTaskWithRetry(input) {
         const startedAt = Date.now();
         try {
             const output = await runAgent(sessionId, [
-                { role: 'system', content: buildSubagentSystemPrompt({ depth: childDepth, canDelegate, mode }) },
+                {
+                    role: 'system',
+                    content: buildSubagentSystemPrompt({
+                        depth: childDepth,
+                        canDelegate,
+                        mode,
+                    }),
+                },
                 { role: 'user', content: task.prompt },
             ], chatbotId, enableRag, task.model, agentId, channelId, undefined, allowedTools);
             const durationMs = Date.now() - startedAt;
@@ -742,7 +958,14 @@ async function runDelegationTaskWithRetry(input) {
             const shouldRetry = classification === 'transient' && attempt < maxAttempts;
             if (!shouldRetry)
                 break;
-            logger.warn({ parentSessionId, sessionId, attempt, maxAttempts, delayMs, errorText }, 'Delegation retry scheduled after transient error');
+            logger.warn({
+                parentSessionId,
+                sessionId,
+                attempt,
+                maxAttempts,
+                delayMs,
+                errorText,
+            }, 'Delegation retry scheduled after transient error');
             await sleep(delayMs);
             delayMs = Math.min(delayMs * 2, PROACTIVE_AUTO_RETRY_MAX_DELAY_MS);
         }
@@ -756,7 +979,14 @@ async function runDelegationTaskWithRetry(input) {
             const shouldRetry = classification === 'transient' && attempt < maxAttempts;
             if (!shouldRetry)
                 break;
-            logger.warn({ parentSessionId, sessionId, attempt, maxAttempts, delayMs, errorText }, 'Delegation retry scheduled after transient exception');
+            logger.warn({
+                parentSessionId,
+                sessionId,
+                attempt,
+                maxAttempts,
+                delayMs,
+                errorText,
+            }, 'Delegation retry scheduled after transient exception');
             await sleep(delayMs);
             delayMs = Math.min(delayMs * 2, PROACTIVE_AUTO_RETRY_MAX_DELAY_MS);
         }
@@ -776,8 +1006,14 @@ function formatDelegationCompletion(params) {
     const { mode, label, entries, totalDurationMs } = params;
     const completedCount = entries.filter((entry) => entry.run.status === 'completed').length;
     const failedCount = entries.length - completedCount;
-    const overallStatus = failedCount === 0 ? 'completed' : completedCount === 0 ? 'failed' : 'partial';
-    const heading = label?.trim() ? `[Delegate: ${label.trim()}]` : `[Delegate ${mode}]`;
+    const overallStatus = failedCount === 0
+        ? 'completed'
+        : completedCount === 0
+            ? 'failed'
+            : 'partial';
+    const heading = label?.trim()
+        ? `[Delegate: ${label.trim()}]`
+        : `[Delegate ${mode}]`;
     const userLines = [
         `${heading} ${overallStatus} (${completedCount}/${entries.length} completed, ${formatDurationMs(totalDurationMs)}).`,
     ];
@@ -836,7 +1072,13 @@ function formatDelegationCompletion(params) {
 }
 async function publishDelegationCompletion(params) {
     const { parentSessionId, channelId, agentId, forLLM, forUser, artifacts, onProactiveMessage, } = params;
-    storeMessage(parentSessionId, 'assistant', null, 'assistant', forLLM);
+    memoryService.storeMessage({
+        sessionId: parentSessionId,
+        userId: 'assistant',
+        username: null,
+        role: 'assistant',
+        content: forLLM,
+    });
     appendSessionTranscript(agentId, {
         sessionId: parentSessionId,
         channelId,
@@ -849,7 +1091,11 @@ async function publishDelegationCompletion(params) {
         await onProactiveMessage({ text: forUser, artifacts });
         return;
     }
-    logger.info({ parentSessionId, message: forUser, artifactCount: artifacts?.length || 0 }, 'Delegation completion (no proactive channel callback)');
+    logger.info({
+        parentSessionId,
+        message: forUser,
+        artifactCount: artifacts?.length || 0,
+    }, 'Delegation completion (no proactive channel callback)');
 }
 function enqueueDelegationFromSideEffect(params) {
     const { plan, parentSessionId, channelId, chatbotId, enableRag, agentId, onProactiveMessage, parentDepth, } = params;
@@ -951,7 +1197,7 @@ function enqueueDelegationFromSideEffect(params) {
 export async function handleGatewayMessage(req) {
     const startedAt = Date.now();
     const runId = makeAuditRunId('turn');
-    const session = getOrCreateSession(req.sessionId, req.guildId, req.channelId);
+    const session = memoryService.getOrCreateSession(req.sessionId, req.guildId, req.channelId);
     const chatbotId = req.chatbotId ?? session.chatbot_id ?? HYBRIDAI_CHATBOT_ID;
     const enableRag = req.enableRag ?? session.enable_rag === 1;
     const model = req.model ?? session.model ?? HYBRIDAI_MODEL;
@@ -1027,10 +1273,20 @@ export async function handleGatewayMessage(req) {
     if (isVersionOnlyQuestion(req.content)) {
         const resultText = `HybridClaw v${APP_VERSION}`;
         recordSuccessfulTurn({
-            sessionId: req.sessionId, agentId, chatbotId, enableRag, model,
-            channelId: req.channelId, runId, turnIndex,
-            userId: req.userId, username: req.username,
-            userContent: req.content, resultText, toolCallCount: 0, startedAt,
+            sessionId: req.sessionId,
+            agentId,
+            chatbotId,
+            enableRag,
+            model,
+            channelId: req.channelId,
+            runId,
+            turnIndex,
+            userId: req.userId,
+            username: req.username,
+            userContent: req.content,
+            resultText,
+            toolCallCount: 0,
+            startedAt,
         });
         return {
             status: 'success',
@@ -1038,10 +1294,39 @@ export async function handleGatewayMessage(req) {
             toolsUsed: [],
         };
     }
-    const history = getConversationHistory(req.sessionId, MAX_HISTORY_MESSAGES);
+    const history = memoryService.getConversationHistory(req.sessionId, MAX_HISTORY_MESSAGES);
+    let canonicalContext = {
+        summary: null,
+        recent_messages: [],
+    };
+    if (req.userId.trim()) {
+        try {
+            canonicalContext = memoryService.getCanonicalContext({
+                agentId,
+                userId: req.userId,
+                windowSize: 12,
+                excludeSessionId: req.sessionId,
+            });
+        }
+        catch (err) {
+            logger.debug({ sessionId: req.sessionId, userId: req.userId, err }, 'Failed to load canonical session context');
+        }
+    }
+    const canonicalPromptSummary = formatCanonicalContextPrompt({
+        summary: canonicalContext.summary,
+        recentMessages: canonicalContext.recent_messages,
+    });
+    const memoryContext = memoryService.buildPromptMemoryContext({
+        session,
+        query: req.content,
+    });
+    const mergedSessionSummary = [canonicalPromptSummary, memoryContext.promptSummary]
+        .filter((value) => typeof value === 'string' && value.trim().length > 0)
+        .join('\n\n')
+        .trim() || null;
     const { messages, skills, historyStats } = buildConversationContext({
         agentId,
-        sessionSummary: session.session_summary,
+        sessionSummary: mergedSessionSummary,
         history,
         runtimeInfo: {
             chatbotId,
@@ -1069,6 +1354,8 @@ export async function handleGatewayMessage(req) {
             perMessageTruncatedCount: historyStats.perMessageTruncatedCount,
             middleCompressionApplied: historyStats.middleCompressionApplied,
             historyEstimatedTokens: estimateTokenCountFromMessages(messages.slice(historyStart)),
+            canonicalSummaryIncluded: Boolean(canonicalPromptSummary),
+            canonicalRecentMessagesIncluded: canonicalContext.recent_messages.length,
         },
     });
     const mediaPolicy = resolveMediaToolPolicy(req.content, media);
@@ -1091,12 +1378,17 @@ export async function handleGatewayMessage(req) {
     try {
         const scheduledTasks = getTasksForSession(req.sessionId);
         const output = await runAgent(req.sessionId, messages, chatbotId, enableRag, model, agentId, req.channelId, scheduledTasks, undefined, mediaPolicy.blockedTools, req.onTextDelta, req.onToolProgress, req.abortSignal, media);
+        const effectiveUserContent = typeof output.effectiveUserPrompt === 'string' &&
+            output.effectiveUserPrompt.trim()
+            ? output.effectiveUserPrompt.trim()
+            : req.content;
         const toolExecutions = output.toolExecutions || [];
         emitToolExecutionAuditEvents({
             sessionId: req.sessionId,
             runId,
             toolExecutions,
         });
+        const usagePayload = buildTokenUsageAuditPayload(messages, output.result, output.tokenUsage);
         recordAuditEvent({
             sessionId: req.sessionId,
             runId,
@@ -1106,25 +1398,44 @@ export async function handleGatewayMessage(req) {
                 model,
                 durationMs: Date.now() - startedAt,
                 toolCallCount: toolExecutions.length,
-                ...buildTokenUsageAuditPayload(messages, output.result, output.tokenUsage),
+                ...usagePayload,
             },
         });
+        recordUsageEvent({
+            sessionId: req.sessionId,
+            agentId,
+            model,
+            inputTokens: firstNumber([usagePayload.promptTokens]) || 0,
+            outputTokens: firstNumber([usagePayload.completionTokens]) || 0,
+            totalTokens: firstNumber([usagePayload.totalTokens]) || 0,
+            toolCalls: toolExecutions.length,
+            costUsd: extractUsageCostUsd(output.tokenUsage),
+        });
         const parentDepth = extractDelegationDepth(req.sessionId);
         let acceptedDelegations = 0;
         processSideEffects(output, req.sessionId, req.channelId, {
             onDelegation: (effect) => {
                 const normalized = normalizeDelegationEffect(effect, model);
                 if (!normalized.plan) {
-                    logger.warn({ sessionId: req.sessionId, error: normalized.error || 'unknown', effect }, 'Delegation skipped — invalid payload');
+                    logger.warn({
+                        sessionId: req.sessionId,
+                        error: normalized.error || 'unknown',
+                        effect,
+                    }, 'Delegation skipped — invalid payload');
                     return;
                 }
                 const childDepth = parentDepth + 1;
                 if (childDepth > PROACTIVE_DELEGATION_MAX_DEPTH) {
-                    logger.info({ sessionId: req.sessionId, childDepth, maxDepth: PROACTIVE_DELEGATION_MAX_DEPTH }, 'Delegation skipped — depth limit reached');
+                    logger.info({
+                        sessionId: req.sessionId,
+                        childDepth,
+                        maxDepth: PROACTIVE_DELEGATION_MAX_DEPTH,
+                    }, 'Delegation skipped — depth limit reached');
                     return;
                 }
                 const requestedRuns = normalized.plan.tasks.length;
-                if (acceptedDelegations + requestedRuns > PROACTIVE_DELEGATION_MAX_PER_TURN) {
+                if (acceptedDelegations + requestedRuns >
+                    PROACTIVE_DELEGATION_MAX_PER_TURN) {
                     logger.info({
                         sessionId: req.sessionId,
                         limit: PROACTIVE_DELEGATION_MAX_PER_TURN,
@@ -1193,10 +1504,20 @@ export async function handleGatewayMessage(req) {
         }
         const resultText = output.result || 'No response from agent.';
         recordSuccessfulTurn({
-            sessionId: req.sessionId, agentId, chatbotId, enableRag, model,
-            channelId: req.channelId, runId, turnIndex,
-            userId: req.userId, username: req.username,
-            userContent: req.content, resultText, toolCallCount: toolExecutions.length, startedAt,
+            sessionId: req.sessionId,
+            agentId,
+            chatbotId,
+            enableRag,
+            model,
+            channelId: req.channelId,
+            runId,
+            turnIndex,
+            userId: req.userId,
+            username: req.username,
+            userContent: effectiveUserContent,
+            resultText,
+            toolCallCount: toolExecutions.length,
+            startedAt,
         });
         return {
             status: 'success',
@@ -1205,6 +1526,7 @@ export async function handleGatewayMessage(req) {
             artifacts: output.artifacts,
             toolExecutions,
             tokenUsage: output.tokenUsage,
+            effectiveUserPrompt: output.effectiveUserPrompt,
         };
     }
     catch (err) {
@@ -1253,8 +1575,8 @@ export async function handleGatewayMessage(req) {
         };
     }
 }
-export async function runGatewayScheduledTask(origSessionId, channelId, prompt, taskId, onResult, onError) {
-    const session = getOrCreateSession(origSessionId, null, channelId);
+export async function runGatewayScheduledTask(origSessionId, channelId, prompt, taskId, onResult, onError, runKey) {
+    const session = memoryService.getOrCreateSession(origSessionId, null, channelId);
     const chatbotId = session.chatbot_id || HYBRIDAI_CHATBOT_ID;
     if (!chatbotId)
         return;
@@ -1267,13 +1589,14 @@ export async function runGatewayScheduledTask(origSessionId, channelId, prompt,
         chatbotId,
         model,
         agentId,
+        sessionKey: runKey,
         onResult,
         onError,
     });
 }
 export async function handleGatewayCommand(req) {
     const cmd = (req.args[0] || '').toLowerCase();
-    const session = getOrCreateSession(req.sessionId, req.guildId, req.channelId);
+    const session = memoryService.getOrCreateSession(req.sessionId, req.guildId, req.channelId);
     switch (cmd) {
         case 'help': {
             const help = [
@@ -1284,11 +1607,20 @@ export async function handleGatewayCommand(req) {
                 '`model set <name>` — Set model for this session',
                 '`model info` — Show current model',
                 '`rag [on|off]` — Toggle or set RAG mode',
+                '`channel mode [off|mention|free]` — Set or inspect this Discord channel response mode',
+                '`channel policy [open|allowlist|disabled]` — Set or inspect guild channel policy',
                 '`ralph [on|off|set <n>|info]` — Configure Ralph loop (0 off, -1 unlimited)',
                 '`clear` — Clear session history',
                 '`/status` — Show runtime status (Discord slash command, private to caller)',
+                '`/approve [view|yes|session|agent|no] [approval_id]` — View/respond to pending approvals privately',
+                '`/channel-mode <off|mention|free>` — Set this Discord channel response mode',
+                '`/channel-policy <open|allowlist|disabled>` — Set Discord guild channel policy',
                 '`sessions` — List active sessions',
-                '`schedule add "<cron>" <prompt>` — Add scheduled task',
+                '`usage [summary|daily|monthly|model [daily|monthly] [agentId]]` — Usage/cost aggregates',
+                '`export session [sessionId]` — Export session JSONL snapshot for debugging',
+                '`schedule add "<cron>" <prompt>` — Add cron scheduled task',
+                '`schedule add at "<ISO time>" <prompt>` — Add one-shot task',
+                '`schedule add every <ms> <prompt>` — Add interval task',
                 '`schedule list` — List scheduled tasks',
                 '`schedule remove <id>` — Remove a task',
                 '`schedule toggle <id>` — Enable/disable a task',
@@ -1302,7 +1634,9 @@ export async function handleGatewayCommand(req) {
                     const bots = await fetchHybridAIBots({ cacheTtlMs: BOT_CACHE_TTL });
                     if (bots.length === 0)
                         return plainCommand('No bots available.');
-                    const list = bots.map((b) => `• ${b.name} (${b.id})${b.description ? ` — ${b.description}` : ''}`).join('\n');
+                    const list = bots
+                        .map((b) => `• ${b.name} (${b.id})${b.description ? ` — ${b.description}` : ''}`)
+                        .join('\n');
                     return infoCommand('Available Bots', list);
                 }
                 catch (err) {
@@ -1316,7 +1650,8 @@ export async function handleGatewayCommand(req) {
                 let resolvedBotId = requested;
                 try {
                     const bots = await fetchHybridAIBots({ cacheTtlMs: BOT_CACHE_TTL });
-                    const matched = bots.find((b) => b.id === requested || b.name.toLowerCase() === requested.toLowerCase());
+                    const matched = bots.find((b) => b.id === requested ||
+                        b.name.toLowerCase() === requested.toLowerCase());
                     if (matched)
                         resolvedBotId = matched.id;
                 }
@@ -1355,7 +1690,8 @@ export async function handleGatewayCommand(req) {
                 const modelName = req.args[2];
                 if (!modelName)
                     return badCommand('Usage', 'Usage: `model set <name>`');
-                if (HYBRIDAI_MODELS.length > 0 && !HYBRIDAI_MODELS.includes(modelName)) {
+                if (HYBRIDAI_MODELS.length > 0 &&
+                    !HYBRIDAI_MODELS.includes(modelName)) {
                     return badCommand('Unknown Model', `\`${modelName}\` is not in the available models list.`);
                 }
                 updateSessionModel(session.id, modelName);
@@ -1380,6 +1716,60 @@ export async function handleGatewayCommand(req) {
             }
             return badCommand('Usage', 'Usage: `rag [on|off]`');
         }
+        case 'channel': {
+            const sub = (req.args[1] || '').toLowerCase();
+            if (sub === 'mode' || !sub) {
+                const guildId = req.guildId;
+                if (!guildId) {
+                    return badCommand('Guild Only', '`channel mode` is only available in Discord guild channels.');
+                }
+                const requestedMode = (req.args[sub ? 2 : 1] || '').toLowerCase();
+                if (!requestedMode) {
+                    const currentMode = resolveGuildChannelMode(guildId, req.channelId);
+                    return infoCommand('Channel Mode', [
+                        `Current mode: \`${currentMode}\``,
+                        `Group policy: \`${DISCORD_GROUP_POLICY}\``,
+                        `Config path: \`discord.guilds.${guildId}.channels.${req.channelId}.mode\``,
+                        'Usage: `channel mode off|mention|free`',
+                    ].join('\n'));
+                }
+                if (!DISCORD_CHANNEL_MODE_VALUES.has(requestedMode)) {
+                    return badCommand('Usage', 'Usage: `channel mode off|mention|free`');
+                }
+                const mode = requestedMode;
+                updateRuntimeConfig((draft) => {
+                    const guild = draft.discord.guilds[guildId] ?? {
+                        defaultMode: 'mention',
+                        channels: {},
+                    };
+                    guild.channels[req.channelId] = { mode };
+                    draft.discord.guilds[guildId] = guild;
+                });
+                return plainCommand(`Set channel mode to \`${mode}\` for this channel. (Policy: \`${DISCORD_GROUP_POLICY}\`)`);
+            }
+            if (sub === 'policy') {
+                const requestedPolicy = (req.args[2] || '').toLowerCase();
+                if (!requestedPolicy) {
+                    return infoCommand('Channel Policy', [
+                        `Current policy: \`${DISCORD_GROUP_POLICY}\``,
+                        'Policies:',
+                        '• `open` — all guild channels are active unless a per-channel mode overrides',
+                        '• `allowlist` — only channels listed under `discord.guilds.<guild>.channels` are active',
+                        '• `disabled` — all guild channels are disabled',
+                        'Usage: `channel policy open|allowlist|disabled`',
+                    ].join('\n'));
+                }
+                if (!DISCORD_GROUP_POLICY_VALUES.has(requestedPolicy)) {
+                    return badCommand('Usage', 'Usage: `channel policy open|allowlist|disabled`');
+                }
+                const policy = requestedPolicy;
+                updateRuntimeConfig((draft) => {
+                    draft.discord.groupPolicy = policy;
+                });
+                return plainCommand(`Discord group policy set to \`${policy}\`.`);
+            }
+            return badCommand('Usage', 'Usage: `channel mode [off|mention|free]` or `channel policy [open|allowlist|disabled]`');
+        }
         case 'ralph': {
             const sub = (req.args[1] || '').toLowerCase();
             if (!sub || sub === 'info' || sub === 'status') {
@@ -1392,7 +1782,10 @@ export async function handleGatewayCommand(req) {
             }
             let nextValue = null;
             if (sub === 'on') {
-                nextValue = PROACTIVE_RALPH_MAX_ITERATIONS === 0 ? 3 : PROACTIVE_RALPH_MAX_ITERATIONS;
+                nextValue =
+                    PROACTIVE_RALPH_MAX_ITERATIONS === 0
+                        ? 3
+                        : PROACTIVE_RALPH_MAX_ITERATIONS;
             }
             else if (sub === 'off') {
                 nextValue = 0;
@@ -1431,22 +1824,25 @@ export async function handleGatewayCommand(req) {
             return plainCommand(`Ralph loop set to ${formatRalphIterations(normalized)}.${restartNote}`);
         }
         case 'clear': {
-            const deleted = clearSessionHistory(session.id);
+            const deleted = memoryService.clearSessionHistory(session.id);
             return infoCommand('Session Cleared', `Deleted ${deleted} messages. Workspace files preserved.`);
         }
         case 'status': {
             const status = getGatewayStatus();
             const delegationStatus = delegationQueueStatus();
-            const metrics = readSessionStatusSnapshot(session.id);
             const commitShort = resolveGitCommitShort();
             const sessionModel = session.model || HYBRIDAI_MODEL;
+            const modelContextWindowTokens = resolveModelContextWindowFallback(sessionModel);
+            const metrics = readSessionStatusSnapshot(session.id, {
+                modelContextWindowTokens,
+            });
             const queueLabel = `${delegationStatus.active} active / ${delegationStatus.queued} queued`;
             const proactiveQueued = getQueuedProactiveMessageCount();
             const cacheKnown = metrics.cacheReadTokens != null || metrics.cacheWriteTokens != null;
-            const contextLabel = (metrics.contextUsedTokens != null && metrics.contextBudgetTokens != null)
+            const contextLabel = metrics.contextUsedTokens != null && metrics.contextBudgetTokens != null
                 ? `${formatCompactNumber(metrics.contextUsedTokens)}/${formatCompactNumber(metrics.contextBudgetTokens)} (${formatPercent(metrics.contextUsagePercent)})`
                 : metrics.contextUsedTokens != null
-                    ? `${formatCompactNumber(metrics.contextUsedTokens)} est`
+                    ? `${formatCompactNumber(metrics.contextUsedTokens)}/? (window unknown)`
                     : 'n/a';
             const lines = [
                 `🦞 HybridClaw v${status.version}${commitShort ? ` (${commitShort})` : ''}`,
@@ -1467,16 +1863,137 @@ export async function handleGatewayCommand(req) {
             const sessions = getAllSessions();
             if (sessions.length === 0)
                 return plainCommand('No active sessions.');
-            const list = sessions.slice(0, 20).map((s) => `${s.id} — ${s.message_count} msgs, last active ${s.last_active}`).join('\n');
+            const list = sessions
+                .slice(0, 20)
+                .map((s) => `${s.id} — ${s.message_count} msgs, last active ${s.last_active}`)
+                .join('\n');
             return infoCommand('Sessions', list);
         }
+        case 'usage': {
+            const sub = (req.args[1] || 'summary').toLowerCase();
+            if (sub === 'daily' || sub === 'monthly') {
+                const rows = listUsageByAgent({ window: sub });
+                if (rows.length === 0) {
+                    return plainCommand(`No usage events recorded for ${sub} window.`);
+                }
+                const lines = rows.slice(0, 20).map((row) => {
+                    return `${row.agent_id} — ${formatCompactNumber(row.total_tokens)} tokens (${formatCompactNumber(row.total_input_tokens)} in / ${formatCompactNumber(row.total_output_tokens)} out) · ${row.call_count} calls · ${formatUsd(row.total_cost_usd)}`;
+                });
+                return infoCommand(`Usage (${sub} · by agent)`, lines.join('\n'));
+            }
+            if (sub === 'model') {
+                const maybeWindow = (req.args[2] || '').toLowerCase();
+                const window = maybeWindow === 'daily' || maybeWindow === 'monthly'
+                    ? maybeWindow
+                    : 'monthly';
+                const modelAgentId = maybeWindow === 'daily' || maybeWindow === 'monthly'
+                    ? (req.args[3] || '').trim()
+                    : (req.args[2] || '').trim();
+                const rows = listUsageByModel({
+                    window,
+                    agentId: modelAgentId || undefined,
+                });
+                if (rows.length === 0) {
+                    return plainCommand('No usage events recorded for model breakdown.');
+                }
+                const lines = rows.slice(0, 20).map((row) => {
+                    return `${row.model} — ${formatCompactNumber(row.total_tokens)} tokens · ${row.call_count} calls · ${formatUsd(row.total_cost_usd)}`;
+                });
+                const scope = modelAgentId ? `agent ${modelAgentId}` : 'all agents';
+                return infoCommand(`Usage (${window} · by model · ${scope})`, lines.join('\n'));
+            }
+            if (sub !== 'summary') {
+                return badCommand('Usage', 'Usage: `usage [summary|daily|monthly|model [daily|monthly] [agentId]]`');
+            }
+            const currentAgentId = resolveSessionAgentId(session);
+            const daily = getUsageTotals({
+                agentId: currentAgentId || undefined,
+                window: 'daily',
+            });
+            const monthly = getUsageTotals({
+                agentId: currentAgentId || undefined,
+                window: 'monthly',
+            });
+            const topModels = listUsageByModel({
+                agentId: currentAgentId || undefined,
+                window: 'monthly',
+            }).slice(0, 5);
+            const scopeLabel = currentAgentId || 'all agents';
+            const lines = [
+                `Scope: ${scopeLabel}`,
+                `Today: ${formatCompactNumber(daily.total_tokens)} tokens · ${daily.call_count} calls · ${formatUsd(daily.total_cost_usd)}`,
+                `Month: ${formatCompactNumber(monthly.total_tokens)} tokens · ${monthly.call_count} calls · ${formatUsd(monthly.total_cost_usd)}`,
+            ];
+            if (topModels.length > 0) {
+                lines.push('Top models (monthly):');
+                lines.push(...topModels.map((row) => `- ${row.model}: ${formatCompactNumber(row.total_tokens)} tokens · ${formatUsd(row.total_cost_usd)}`));
+            }
+            return infoCommand('Usage Summary', lines.join('\n'));
+        }
+        case 'export': {
+            const sub = (req.args[1] || 'session').toLowerCase();
+            if (sub !== 'session') {
+                return badCommand('Usage', 'Usage: `export session [sessionId]`');
+            }
+            const targetSessionId = (req.args[2] || session.id || '').trim();
+            if (!targetSessionId) {
+                return badCommand('Usage', 'Usage: `export session [sessionId]`');
+            }
+            const targetSession = memoryService.getSessionById(targetSessionId);
+            if (!targetSession) {
+                return badCommand('Not Found', `Session \`${targetSessionId}\` was not found.`);
+            }
+            const exportAgentId = resolveSessionAgentId(targetSession) || resolveSessionAgentId(session);
+            if (!exportAgentId) {
+                return badCommand('Missing Agent', 'Cannot export session: no agent/chatbot is configured for the target session.');
+            }
+            const messages = memoryService.getRecentMessages(targetSessionId);
+            const exported = exportSessionSnapshotJsonl({
+                agentId: exportAgentId,
+                sessionId: targetSessionId,
+                channelId: targetSession.channel_id,
+                summary: targetSession.session_summary,
+                messages,
+                reason: 'manual',
+            });
+            if (!exported) {
+                return badCommand('Export Failed', 'Failed to write session export JSONL file. Check gateway logs for details.');
+            }
+            return infoCommand('Session Exported', [
+                `File: ${exported.path}`,
+                `Messages: ${messages.length}`,
+                `Summary: ${targetSession.session_summary ? 'yes' : 'no'}`,
+            ].join('\n'));
+        }
         case 'schedule': {
             const sub = req.args[1]?.toLowerCase();
             if (sub === 'add') {
                 const rest = req.args.slice(2).join(' ');
+                const atMatch = rest.match(/^at\s+"([^"]+)"\s+(.+)$/i);
+                if (atMatch) {
+                    const [, runAtRaw, prompt] = atMatch;
+                    const parsedDate = new Date(runAtRaw);
+                    if (Number.isNaN(parsedDate.getTime())) {
+                        return badCommand('Invalid Time', `\`${runAtRaw}\` is not a valid ISO timestamp.`);
+                    }
+                    const taskId = createTask(session.id, req.channelId, '', prompt, parsedDate.toISOString());
+                    rearmScheduler();
+                    return plainCommand(`Task #${taskId} created: one-shot at \`${parsedDate.toISOString()}\` — ${prompt}`);
+                }
+                const everyMatch = rest.match(/^every\s+(\d+)\s+(.+)$/i);
+                if (everyMatch) {
+                    const [, everyRaw, prompt] = everyMatch;
+                    const everyMs = Number.parseInt(everyRaw, 10);
+                    if (!Number.isFinite(everyMs) || everyMs < 10_000) {
+                        return badCommand('Invalid Interval', 'Interval must be at least 10000ms.');
+                    }
+                    const taskId = createTask(session.id, req.channelId, '', prompt, undefined, everyMs);
+                    rearmScheduler();
+                    return plainCommand(`Task #${taskId} created: every \`${everyMs}ms\` — ${prompt}`);
+                }
                 const cronMatch = rest.match(/^"([^"]+)"\s+(.+)$/);
                 if (!cronMatch) {
-                    return badCommand('Usage', 'Usage: `schedule add "<cron>" <prompt>`');
+                    return badCommand('Usage', 'Usage: `schedule add "<cron>" <prompt>` or `schedule add at "<ISO time>" <prompt>` or `schedule add every <ms> <prompt>`');
                 }
                 const [, cronExpr, prompt] = cronMatch;
                 try {
@@ -1487,13 +2004,28 @@ export async function handleGatewayCommand(req) {
                 }
                 const taskId = createTask(session.id, req.channelId, cronExpr, prompt);
                 rearmScheduler();
-                return plainCommand(`Task #${taskId} created: \`${cronExpr}\` — ${prompt}`);
+                return plainCommand(`Task #${taskId} created: cron \`${cronExpr}\` — ${prompt}`);
             }
             if (sub === 'list') {
                 const tasks = getTasksForSession(session.id);
                 if (tasks.length === 0)
                     return plainCommand('No scheduled tasks.');
-                const list = tasks.map((task) => `#${task.id} ${task.enabled ? 'enabled' : 'disabled'} \`${task.cron_expr}\` — ${task.prompt.slice(0, 60)}`).join('\n');
+                const list = tasks
+                    .map((task) => {
+                    const scheduleLabel = task.run_at
+                        ? `at ${task.run_at}`
+                        : task.every_ms
+                            ? `every ${task.every_ms}ms`
+                            : task.cron_expr
+                                ? `cron ${task.cron_expr}`
+                                : 'unspecified';
+                    const statusLabel = task.last_status || 'n/a';
+                    const errorSuffix = task.consecutive_errors > 0
+                        ? ` · errors ${task.consecutive_errors}`
+                        : '';
+                    return `#${task.id} ${task.enabled ? 'enabled' : 'disabled'} (${scheduleLabel}) [${statusLabel}${errorSuffix}] — ${task.prompt.slice(0, 60)}`;
+                })
+                    .join('\n');
                 return infoCommand('Scheduled Tasks', list);
             }
             if (sub === 'remove') {
@@ -1512,7 +2044,12 @@ export async function handleGatewayCommand(req) {
                 const task = tasks.find((t) => t.id === taskId);
                 if (!task)
                     return badCommand('Not Found', `Task #${taskId} was not found in this session.`);
-                toggleTask(taskId, !Boolean(task.enabled));
+                if (task.enabled) {
+                    pauseTask(taskId);
+                }
+                else {
+                    resumeTask(taskId);
+                }
                 rearmScheduler();
                 return plainCommand(`Task #${taskId} ${task.enabled ? 'disabled' : 'enabled'}.`);
             }