@c4t4/heyamigo 0.10.0 → 0.10.2

package/dist/cli/setup.js

@@ -65,6 +65,32 @@ function setConfigOwnerNumber(configPath, number) {
     }
     catch { }
 }
+function readConfigObject(configPath) {
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getConfiguredProvider(configPath) {
+    const cfg = readConfigObject(configPath);
+    const ai = cfg?.ai;
+    if (ai && typeof ai === 'object') {
+        const provider = ai.provider;
+        if (provider === 'claude' || provider === 'codex' || provider === 'grok') {
+            return provider;
+        }
+    }
+    return 'claude';
+}
+function setConfiguredProvider(configPath, provider) {
+    const cfg = readConfigObject(configPath);
+    if (!cfg)
+        return;
+    cfg.ai = { ...(cfg.ai ?? {}), provider };
+    writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+}
 function findPackageDir() {
     // __pkgRoot = two levels up from dist/cli/ = package root
     if (existsSync(resolve(__pkgRoot, 'config', 'config.example.json'))) {
@@ -236,27 +262,55 @@ export async function runSetup() {
     else {
         p.log.info('access.json already exists');
     }
-    // ── Claude CLI (critical — bot cannot work without this) ─────
-    const claudePath = which('claude');
-    if (!claudePath) {
-        p.cancel('Claude CLI is required but was not found.\n' +
-            'Install it first, then re-run setup:\n\n' +
-            '  npm install -g @anthropic-ai/claude-code\n\n' +
-            'For other install methods see: https://docs.anthropic.com/en/docs/claude-code');
-        process.exit(1);
-    }
-    p.log.success('Claude CLI found');
-    // Auth (critical — bot uses your Claude subscription, not API)
-    const authenticated = run('claude auth status').ok;
-    if (!authenticated) {
-        p.cancel('Claude is not logged in.\n' +
-            'Run claude in your terminal and follow the login instructions:\n\n' +
-            '  claude\n\n' +
-            'Once logged in, re-run: npx @c4t4/heyamigo setup');
-        process.exit(1);
-    }
-    p.log.success('Claude authenticated');
-    {
+    // ── AI provider ───────────────────────────────────────────────
+    const currentProvider = getConfiguredProvider(configPath);
+    const providerChoice = await p.select({
+        message: 'Choose AI provider',
+        options: [
+            {
+                value: 'claude',
+                label: 'Claude',
+                hint: 'Claude Code CLI',
+            },
+            {
+                value: 'grok',
+                label: 'Grok Build',
+                hint: 'xAI Grok Build CLI',
+            },
+            {
+                value: 'codex',
+                label: 'Codex',
+                hint: 'OpenAI Codex CLI',
+            },
+        ],
+        initialValue: currentProvider,
+    });
+    const provider = p.isCancel(providerChoice)
+        ? currentProvider
+        : providerChoice;
+    setConfiguredProvider(configPath, provider);
+    p.log.success(`AI provider: ${provider}`);
+    if (provider === 'claude') {
+        // ── Claude CLI (critical — bot cannot work without this) ─────
+        const claudePath = which('claude');
+        if (!claudePath) {
+            p.cancel('Claude CLI is required but was not found.\n' +
+                'Install it first, then re-run setup:\n\n' +
+                '  npm install -g @anthropic-ai/claude-code\n\n' +
+                'For other install methods see: https://docs.anthropic.com/en/docs/claude-code');
+            process.exit(1);
+        }
+        p.log.success('Claude CLI found');
+        // Auth (critical — bot uses your Claude subscription, not API)
+        const authenticated = run('claude auth status').ok;
+        if (!authenticated) {
+            p.cancel('Claude is not logged in.\n' +
+                'Run claude in your terminal and follow the login instructions:\n\n' +
+                '  claude\n\n' +
+                'Once logged in, re-run: npx @c4t4/heyamigo setup');
+            process.exit(1);
+        }
+        p.log.success('Claude authenticated');
         // Tool permissions — write .claude/settings.json in project root.
         p.log.info('Claude needs tool permissions to browse the web, read files, and control the browser. ' +
             'This writes a .claude/settings.json file in the project directory.');
@@ -315,15 +369,44 @@ export async function runSetup() {
             catch {
                 // Non-critical, trust prompt will appear on first run
             }
-        } // end grant permissions
-    } // end claude cli block
+        }
+    }
+    else if (provider === 'grok') {
+        // ── Grok Build CLI ──────────────────────────────────────────
+        const grokPath = which('grok');
+        if (!grokPath) {
+            p.cancel('Grok Build CLI is required but was not found.\n' +
+                'Install it first, then re-run setup:\n\n' +
+                '  curl -fsSL https://x.ai/cli/install.sh | bash');
+            process.exit(1);
+        }
+        p.log.success('Grok Build CLI found');
+        if (!process.env.XAI_API_KEY) {
+            p.log.info('If Grok is not logged in on this machine yet, run:\n\n' +
+                '  grok login\n\n' +
+                'Headless servers can also use XAI_API_KEY.');
+        }
+    }
+    else {
+        // ── Codex CLI ───────────────────────────────────────────────
+        const codexPath = which('codex');
+        if (!codexPath) {
+            p.cancel('Codex CLI is required but was not found.\n' +
+                'Install it first, then re-run setup:\n\n' +
+                '  npm install -g @openai/codex');
+            process.exit(1);
+        }
+        p.log.success('Codex CLI found');
+        p.log.info('If Codex is not logged in on this machine yet, run:\n\n' +
+            '  codex login');
+    }
     // ── Shared browser (optional) ──────────────────────────────────
-    p.log.info('Claude can control a real Chrome browser to browse websites, ' +
+    p.log.info('The AI provider can control a real Chrome browser to browse websites, ' +
         'fill forms, take screenshots, and interact with web apps. ' +
         'Everything runs on localhost only, nothing is exposed publicly. ' +
         'You can connect to watch the browser via a secure SSH tunnel.');
     const wantBrowser = await p.confirm({
-        message: 'Enable browser control for Claude?',
+        message: 'Enable browser control?',
         initialValue: false,
     });
     if (!p.isCancel(wantBrowser) && wantBrowser) {
@@ -332,17 +415,22 @@ export async function runSetup() {
             p.log.warning('Automated browser setup is available on Linux only. ' +
                 'On macOS/Windows: start Chrome with --remote-debugging-port=9222 manually, ' +
                 'then for Claude: claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "http://localhost:9222"; ' +
-                'for Codex: add [mcp_servers.playwright] to ~/.codex/config.toml.');
+                'for Codex: add [mcp_servers.playwright] to ~/.codex/config.toml; ' +
+                'for Grok: use grok mcp to add the same Playwright MCP server.');
         }
         else {
             // ── Check if already running ─────────────────────────────
             const cdpUrl = 'http://localhost:9222';
             const alreadyRunning = run(`curl -s '${cdpUrl}/json/version'`);
-            const mcpConfigured = run('claude mcp list 2>/dev/null').output.includes('playwright');
+            const hasClaude = !!which('claude');
+            const mcpConfigured = hasClaude && run('claude mcp list 2>/dev/null').output.includes('playwright');
             const hasCodex = !!which('codex');
-            if (alreadyRunning.ok && alreadyRunning.output.includes('Browser') && mcpConfigured) {
+            const hasGrok = !!which('grok');
+            if (alreadyRunning.ok && alreadyRunning.output.includes('Browser')) {
                 p.log.success('Chrome already running (localhost:9222)');
-                p.log.success('Claude already connected to Chrome');
+                if (hasClaude && mcpConfigured) {
+                    p.log.success('Claude already connected to Chrome');
+                }
                 if (hasCodex) {
                     if (addPlaywrightToCodexConfig(cdpUrl)) {
                         p.log.success('Codex connected to Chrome (~/.codex/config.toml)');
@@ -351,6 +439,9 @@ export async function runSetup() {
                         p.log.warning('Could not write ~/.codex/config.toml — add [mcp_servers.playwright] manually');
                     }
                 }
+                if (hasGrok) {
+                    p.log.info('For Grok, add Playwright MCP with grok mcp if it is not already configured.');
+                }
                 p.log.info('View browser (SSH tunnel):\n' +
                     `  ssh -L 6090:127.0.0.1:6090 ${process.env.USER || 'root'}@<server-ip>\n` +
                     '  Then open: http://localhost:6090/vnc.html');
@@ -426,18 +517,20 @@ export async function runSetup() {
                     const cdpCheck = run(`curl -s '${cdpUrl}/json/version'`);
                     if (cdpCheck.ok && cdpCheck.output.includes('Browser')) {
                         p.log.success('Chrome running (localhost:9222, not public)');
-                        // Connect Claude to Chrome via CDP
-                        const sc = p.spinner();
-                        sc.start('Connecting Claude to Chrome');
-                        run('claude mcp remove playwright');
-                        const addResult = run(`claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "${cdpUrl}"`);
-                        if (addResult.ok ||
-                            addResult.output.includes('already exists')) {
-                            sc.stop('Claude connected to Chrome');
-                        }
-                        else {
-                            sc.stop('Connection failed');
-                            p.log.warning('Run manually: claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "http://localhost:9222"');
+                        if (hasClaude) {
+                            // Connect Claude to Chrome via CDP
+                            const sc = p.spinner();
+                            sc.start('Connecting Claude to Chrome');
+                            run('claude mcp remove playwright');
+                            const addResult = run(`claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "${cdpUrl}"`);
+                            if (addResult.ok ||
+                                addResult.output.includes('already exists')) {
+                                sc.stop('Claude connected to Chrome');
+                            }
+                            else {
+                                sc.stop('Connection failed');
+                                p.log.warning('Run manually: claude mcp add playwright -- npx @playwright/mcp@latest --cdp-endpoint "http://localhost:9222"');
+                            }
                         }
                         // Mirror the MCP entry into Codex if it's installed, so the same
                         // browser lane works when ai.provider is flipped to codex.
@@ -449,6 +542,9 @@ export async function runSetup() {
                                 p.log.warning('Could not write ~/.codex/config.toml — add [mcp_servers.playwright] manually');
                             }
                         }
+                        if (hasGrok) {
+                            p.log.info('For Grok, add Playwright MCP with grok mcp if it is not already configured.');
+                        }
                         if (vncInstalled) {
                             p.log.info('Watch the browser (localhost only, via SSH tunnel):\n' +
                                 `  ssh -L 6090:127.0.0.1:6090 ${process.env.USER || 'root'}@<server-ip>\n` +
@@ -663,35 +759,37 @@ export async function runSetup() {
         }
         catch { }
     }
-    // ── Claude model ─────────────────────────────────────────────
-    const model = await p.select({
-        message: 'Choose a Claude model',
-        options: [
-            {
-                value: 'claude-opus-4-7',
-                label: 'Opus',
-                hint: 'highest quality, recommended (default)',
-            },
-            {
-                value: 'claude-sonnet-4-6',
-                label: 'Sonnet',
-                hint: 'faster, lower cost',
-            },
-        ],
-        initialValue: 'claude-opus-4-7',
-    });
-    if (!p.isCancel(model)) {
-        const configPath = resolve(cwd, 'config/config.json');
-        if (existsSync(configPath)) {
-            let cfg = readFileSync(configPath, 'utf-8');
-            cfg = cfg.replace(/"model":\s*"[^"]*"/, `"model": "${model}"`);
-            writeFileSync(configPath, cfg);
-            const label = model === 'claude-sonnet-4-6'
-                ? 'Sonnet'
-                : model === 'claude-opus-4-7'
-                    ? 'Opus'
-                    : 'Haiku';
-            p.log.success(`Model: ${label}`);
+    if (provider === 'claude') {
+        // ── Claude model ─────────────────────────────────────────────
+        const model = await p.select({
+            message: 'Choose a Claude model',
+            options: [
+                {
+                    value: 'claude-opus-4-7',
+                    label: 'Opus',
+                    hint: 'highest quality, recommended (default)',
+                },
+                {
+                    value: 'claude-sonnet-4-6',
+                    label: 'Sonnet',
+                    hint: 'faster, lower cost',
+                },
+            ],
+            initialValue: 'claude-opus-4-7',
+        });
+        if (!p.isCancel(model)) {
+            const configPath = resolve(cwd, 'config/config.json');
+            if (existsSync(configPath)) {
+                let cfg = readFileSync(configPath, 'utf-8');
+                cfg = cfg.replace(/"model":\s*"[^"]*"/, `"model": "${model}"`);
+                writeFileSync(configPath, cfg);
+                const label = model === 'claude-sonnet-4-6'
+                    ? 'Sonnet'
+                    : model === 'claude-opus-4-7'
+                        ? 'Opus'
+                        : 'Haiku';
+                p.log.success(`Model: ${label}`);
+            }
         }
     }
     // ── Personality ──────────────────────────────────────────────

package/dist/cli/start.js

@@ -1,13 +1,34 @@
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { bootBot, installShutdownSignals } from '../boot.js';
+import { config } from '../config.js';
 import { logger } from '../logger.js';
+function requiredCli() {
+    switch (config.ai.provider) {
+        case 'claude':
+            return {
+                bin: 'claude',
+                install: 'npm install -g @anthropic-ai/claude-code',
+            };
+        case 'codex':
+            return {
+                bin: 'codex',
+                install: 'npm install -g @openai/codex',
+            };
+        case 'grok':
+            return {
+                bin: config.grok.bin,
+                install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
+            };
+    }
+}
 export async function main() {
+    const cli = requiredCli();
     try {
-        execSync('which claude', { stdio: 'pipe' });
+        execFileSync('which', [cli.bin], { stdio: 'pipe' });
     }
     catch {
-        console.error('Claude CLI not found. Install it first:\n\n' +
-            '  npm install -g @anthropic-ai/claude-code\n');
+        console.error(`${config.ai.provider} CLI not found. Install it first:\n\n` +
+            `  ${cli.install}\n`);
         process.exit(1);
     }
     installShutdownSignals();

package/dist/config.js

@@ -4,9 +4,20 @@ import { z } from 'zod';
 const TriggerModeSchema = z.enum(['all', 'mention', 'command', 'off']);
 const ConfigSchema = z.object({
     whatsapp: z.object({
+        enabled: z.boolean().default(true),
         authDir: z.string(),
         browserName: z.string(),
     }),
+    telegram: z
+        .object({
+        enabled: z.boolean().default(false),
+        botToken: z.string().optional(),
+        pollIntervalMs: z.number().int().positive().default(1000),
+    })
+        .default({
+        enabled: false,
+        pollIntervalMs: 1000,
+    }),
     owner: z.object({
         number: z.string(),
         treatAsAllowedEverywhere: z.boolean(),
@@ -26,7 +37,7 @@ const ConfigSchema = z.object({
     }),
     ai: z
         .object({
-        provider: z.enum(['claude', 'codex']).default('claude'),
+        provider: z.enum(['claude', 'codex', 'grok']).default('claude'),
     })
         .default({ provider: 'claude' }),
     claude: z.object({
@@ -57,6 +68,7 @@ const ConfigSchema = z.object({
         // Optional model override. If unset, Codex uses its default. Passed
         // as `-m <model>` to `codex exec`.
         model: z.string().optional(),
+        contextWindow: z.number().int().positive().default(200000),
         // Emits --yolo, which bundles no-approvals + full sandbox + skip-
         // trust-check. The narrower verbose flag does not subsume the trust
         // gate on all versions and hangs the process, so --yolo is the safe
@@ -72,6 +84,27 @@ const ConfigSchema = z.object({
         extraArgs: z.array(z.string()).default([]),
     })
         .default({}),
+    grok: z
+        .object({
+        // Binary name or absolute path. xAI's installer puts `grok` on PATH,
+        // but some desktop installs expose it from an app bundle.
+        bin: z.string().default('grok'),
+        // Optional model override. If unset, Grok Build uses its configured
+        // default. Passed as `-m <model>`.
+        model: z.string().optional(),
+        contextWindow: z.number().int().positive().default(1000000),
+        // Headless Grok can prompt for tool approvals. In the bot runtime there
+        // is no human TUI, so auto-approval is the practical default for write
+        // modes; read-only tasks still use plan/read-only settings.
+        alwaysApprove: z.boolean().default(true),
+        // Keep Grok's own cross-session memory out of heyamigo's explicit memory
+        // files unless the operator opts in.
+        memory: z.boolean().default(false),
+        // Appended verbatim to every `grok` invocation. Escape hatch for CLI
+        // version drift without changing code.
+        extraArgs: z.array(z.string()).default([]),
+    })
+        .default({}),
     bootstrap: z.object({
         historyDepth: z.number(),
         includeHistory: z.boolean(),
@@ -118,12 +151,14 @@ const ConfigSchema = z.object({
         promptRetentionDays: z.number(),
     }),
     // Threads — AI-curated relevance watchlist. See src/queue/threads.ts.
-    // Off by default; flip enabled=true to allow the AI to open/track
-    // loops via [THREAD-*:] tags. Reactive surface only in v1 — proactive
-    // review tick (silent-chat check-ins) deferred.
+    // On by default. Reactive surface only in v1: the agent decides
+    // when to open loops, brings them up if naturally relevant, never
+    // sends unsolicited messages. To turn off, set enabled=false in
+    // config.local.json. Proactive review tick (silent-chat check-ins)
+    // is the bit that would be default-off if/when it ships.
     threads: z
         .object({
-        enabled: z.boolean().default(false),
+        enabled: z.boolean().default(true),
         preamblePerChat: z.number().int().positive().default(5),
         // Soft caps used by future cleanup jobs; the worker doesn't read
         // these yet but they're here so config.json can be authored once.
@@ -132,7 +167,7 @@ const ConfigSchema = z.object({
         decayPerDay: z.number().int().min(0).default(2),
     })
         .default({
-        enabled: false,
+        enabled: true,
         preamblePerChat: 5,
         maxActivePerChat: 10,
         hotnessCapOnCreate: 70,

package/dist/db/address.js

@@ -53,6 +53,19 @@ export function addressToExternalId(addr) {
     const a = typeof addr === 'string' ? parseAddress(addr) : addr;
     return a.externalId;
 }
+export function addressToChatKey(addr) {
+    const a = typeof addr === 'string' ? parseAddress(addr) : addr;
+    if (a.channel === 'wa')
+        return a.externalId;
+    return `${a.channel}_${a.scope}_${a.externalId}`.replace(/[^a-zA-Z0-9_.-]/g, '_');
+}
+export function actorKeyFromAddress(addr) {
+    const a = typeof addr === 'string' ? parseAddress(addr) : addr;
+    if (a.channel === 'wa') {
+        return a.externalId.split('@')[0]?.split(':')[0] ?? a.externalId;
+    }
+    return `${a.channel}_${a.externalId}`.replace(/[^a-zA-Z0-9_.-]/g, '_');
+}
 // Convenience predicates.
 export function isGroup(addr) {
     const a = typeof addr === 'string' ? parseAddress(addr) : addr;

package/dist/db/identity-sync.js

@@ -24,11 +24,16 @@ import { identities, persons } from './schema.js';
 import { getAccess } from '../wa/whitelist.js';
 const OWNER_PERSON_ID = 'person-owner';
 function personIdForNumber(number) {
+    if (number.startsWith('tg_'))
+        return `person-${number}`;
     // Strip non-digits, prefix with 'person-'. Stable + deterministic.
     const sanitized = number.replace(/\D/g, '');
     return `person-${sanitized}`;
 }
 function dmAddressFor(number) {
+    if (number.startsWith('tg_')) {
+        return `tg:dm:${number.slice(3)}`;
+    }
     const sanitized = number.replace(/\D/g, '');
     return formatAddress(jidToAddress(`${sanitized}@s.whatsapp.net`));
 }
@@ -171,6 +176,9 @@ export function getTimezoneForAddress(address) {
 export function getTimezoneForSenderNumber(senderNumber) {
     if (!senderNumber)
         return config.owner.timezone;
+    if (senderNumber.startsWith('tg_')) {
+        return getTimezoneForAddress(`tg:dm:${senderNumber.slice(3)}`);
+    }
     const sanitized = senderNumber.replace(/\D/g, '');
     if (!sanitized)
         return config.owner.timezone;

package/dist/gateway/bootstrap.js

@@ -1,35 +1,28 @@
-import { isJidGroup } from 'baileys';
 import { config } from '../config.js';
-import { logger } from '../logger.js';
 import { readLast } from '../store/messages.js';
 export async function buildInitPayload(params) {
-    const { jid, sock, userText, userNumber } = params;
-    const isGroup = isJidGroup(jid) === true;
+    const { jid, userText, userNumber } = params;
+    const chat = params.chat ?? {
+        platform: 'WhatsApp',
+        isGroup: jid.endsWith('@g.us'),
+        externalId: jid,
+    };
     const lines = [];
     if (config.bootstrap.includeChatMetadata) {
-        lines.push('You are the assistant behind a WhatsApp chat.');
-        if (isGroup) {
-            let subject = 'unknown';
-            let participantSummary = '';
-            try {
-                const meta = await sock.groupMetadata(jid);
-                subject = meta.subject || subject;
-                if (meta.participants?.length) {
-                    participantSummary = `${meta.participants.length} participants`;
-                }
-            }
-            catch (err) {
-                logger.warn({ err, jid }, 'group metadata fetch failed in bootstrap');
-            }
+        lines.push(`You are the assistant behind a ${chat.platform} chat.`);
+        if (chat.isGroup) {
             lines.push(`Chat type: group`);
-            lines.push(`Chat name: "${subject}"`);
-            if (participantSummary)
-                lines.push(`Members: ${participantSummary}`);
+            lines.push(`Chat name: "${chat.chatName || 'unknown'}"`);
+            if (chat.memberSummary)
+                lines.push(`Members: ${chat.memberSummary}`);
         }
         else {
             lines.push(`Chat type: direct message`);
         }
-        lines.push(`JID: ${jid}`);
+        lines.push(`Chat key: ${jid}`);
+        if (chat.externalId && chat.externalId !== jid) {
+            lines.push(`External id: ${chat.externalId}`);
+        }
         lines.push('');
     }
     if (config.bootstrap.includeHistory) {

package/dist/gateway/commands.js

@@ -2,7 +2,6 @@ import { clearSession, getSessionInfo } from '../ai/sessions.js';
 import { getProvider, reloadAllSystemPrompts } from '../ai/providers.js';
 import { config } from '../config.js';
 import { runDigestNow } from '../memory/scheduler.js';
-import { sendText } from '../wa/sender.js';
 // Feature-level commands (/journal, /snooze, /tasks, etc.) are intentionally
 // absent. Claude is the interface — the owner asks for things in natural
 // language and Claude acts via markers or by editing files directly.
@@ -24,18 +23,19 @@ export async function tryCommand(ctx) {
         const reply = existed
             ? `Session reset. Next message will bootstrap a fresh ${provider.name} session.`
             : 'No session to reset.';
-        await sendText(ctx.sock, ctx.jid, reply, ctx.quoted);
+        await ctx.reply(reply);
         return true;
     }
     if (config.commands.status.includes(cmd)) {
-        const info = getSessionInfo(ctx.jid, getProvider().name);
+        const provider = getProvider();
+        const info = getSessionInfo(ctx.jid, provider.name);
         if (!info) {
-            await sendText(ctx.sock, ctx.jid, 'No session yet. Next message will bootstrap one.', ctx.quoted);
+            await ctx.reply('No session yet. Next message will bootstrap one.');
             return true;
         }
         const lines = [`Session: ${info.sessionId.slice(0, 8)}…`];
         if (info.usage) {
-            const max = config.claude.contextWindow;
+            const max = provider.contextWindow;
             const used = info.usage.totalContextTokens;
             // Clamp leftPct to [0, 100] so stale or inconsistent data
             // doesn't surface a negative or >100 percentage.
@@ -44,7 +44,7 @@ export async function tryCommand(ctx) {
             lines.push(`Context: ${used.toLocaleString()} / ${max.toLocaleString()} (${leftPct}% left, last turn)`);
             lines.push(`Turns: ${info.usage.numTurns}`);
         }
-        await sendText(ctx.sock, ctx.jid, lines.join('\n'), ctx.quoted);
+        await ctx.reply(lines.join('\n'));
         return true;
     }
     if (config.commands.reload.includes(cmd)) {
@@ -53,11 +53,11 @@ export async function tryCommand(ctx) {
         const reply = existed
             ? 'Personality reloaded and session reset.'
             : 'Personality reloaded.';
-        await sendText(ctx.sock, ctx.jid, reply, ctx.quoted);
+        await ctx.reply(reply);
         return true;
     }
     if (cmd === 'digest') {
-        await sendText(ctx.sock, ctx.jid, 'Digesting memory now, this may take a moment.', ctx.quoted);
+        await ctx.reply('Digesting memory now, this may take a moment.');
         runDigestNow({
             jid: ctx.jid,
             number: ctx.senderNumber || undefined,
@@ -68,27 +68,25 @@ export async function tryCommand(ctx) {
     if (cmd === 'queues') {
         const { takeQueuesSnapshot, formatQueuesSnapshot } = await import('../queue/observability.js');
         const snap = takeQueuesSnapshot();
-        await sendText(ctx.sock, ctx.jid, formatQueuesSnapshot(snap), ctx.quoted);
+        await ctx.reply(formatQueuesSnapshot(snap));
         return true;
     }
     if (cmd === 'reminders' || cmd === 'crons') {
         const { listChatSchedules, formatScheduleList } = await import('../queue/schedule-list.js');
-        const { formatAddress, jidToAddress } = await import('../db/address.js');
         const { getTimezoneForSenderNumber } = await import('../db/identity-sync.js');
-        const chatAddress = formatAddress(jidToAddress(ctx.jid));
         const tz = getTimezoneForSenderNumber(ctx.senderNumber);
         const onlyKind = cmd === 'reminders' ? 'one-shot' : 'recurring';
-        const items = listChatSchedules(chatAddress, onlyKind);
-        await sendText(ctx.sock, ctx.jid, formatScheduleList(items, tz, onlyKind), ctx.quoted);
+        const items = listChatSchedules(ctx.address, onlyKind);
+        await ctx.reply(formatScheduleList(items, tz, onlyKind));
         return true;
     }
     if (cmd === 'threads') {
         if (!config.threads?.enabled) {
-            await sendText(ctx.sock, ctx.jid, 'threads are disabled in config. Set `threads.enabled: true` to turn on.', ctx.quoted);
+            await ctx.reply('threads are disabled in config. Set `threads.enabled: true` to turn on.');
             return true;
         }
         const { handleThreadsCommand } = await import('../queue/thread-list.js');
-        await sendText(ctx.sock, ctx.jid, handleThreadsCommand(ctx.jid, args), ctx.quoted);
+        await ctx.reply(handleThreadsCommand(ctx.jid, args));
         return true;
     }
     return false;