clementine-agent 1.18.19 → 1.18.21

package/dist/agent/route-classifier.d.ts

@@ -29,6 +29,7 @@ export declare function isDirectImperative(userMessage: string): {
     match: boolean;
     pattern?: string;
 };
+export declare function hasNoDelegationInstruction(userMessage: string): boolean;
 /**
  * Decide whether the user is talking ABOUT an agent rather than to them.
  * The explicit-mention fast path otherwise routes a message like

package/dist/agent/route-classifier.js

@@ -91,6 +91,22 @@ export function isDirectImperative(userMessage) {
     }
     return { match: false };
 }
+export function hasNoDelegationInstruction(userMessage) {
+    return /\b(don't|dont|do not|don't you|please don't|please dont)\s+(delegate|route|send|pass|hand ?off|handoff)\b/i.test(userMessage)
+        || /\b(no|without)\s+(delegating|routing|sending|passing|handing ?off|handoff)\b/i.test(userMessage)
+        || /\bkeep (this|that|it)?\s*(with )?(clementine|you|yourself)\b/i.test(userMessage);
+}
+function isExplicitDelegationToAgent(text, firstName, slug) {
+    const ident = `${firstName}|${slug}`;
+    const re = new RegExp(`\\b(send|route|delegate|pass|hand\\s*off|handoff)\\b[\\s\\w']{0,40}?\\b(to\\s+)?(${ident})\\b`, 'i');
+    return re.test(text);
+}
+function isVocativeAgentAddress(text, firstName, slug) {
+    const ident = `${firstName}|${slug}`;
+    const normalized = text.trim();
+    const openerRe = new RegExp(`^(hey\\s+|hi\\s+|yo\\s+)?(${ident})(\\b|\\s*[,—-])`, 'i');
+    return openerRe.test(normalized);
+}
 /**
  * Decide whether the user is talking ABOUT an agent rather than to them.
  * The explicit-mention fast path otherwise routes a message like
@@ -111,8 +127,8 @@ export function isAskingAboutAgent(text, firstName, slug) {
     const possessiveRe = new RegExp(`\\b(${ident})('s|s')\\b`, 'i');
     if (possessiveRe.test(text))
         return true;
-    const askingRe = new RegExp(`\\b(how|what|where|who|when|why|is|are|was|were|did|does|do|will|can|could|would|should|has|have|had|tell\\s+me|show\\s+me|let\\s+me\\s+know|any\\s+update|update\\s+on|status\\s+of|about)\\b[\\s\\w']{0,40}?\\b(${ident})\\b`, 'i');
-    return askingRe.test(text);
+    const askingRe = new RegExp(`\\b(how|what|where|who|when|why|is|are|was|were|did|does|do|will|can|could|would|should|has|have|had|tell\\s+me|show\\s+me|let\\s+me\\s+know|any\\s+update|update\\s+on|status\\s+of|about|fix|check|review)\\b[\\s\\w']{0,80}?\\b(${ident})\\b`, 'i');
+    return askingRe.test(text) || new RegExp(`\\b(for|about|on)\\s+(${ident})\\b`, 'i').test(text);
 }
 /**
  * Session keys eligible for routing. Any key NOT in this set is
@@ -252,6 +268,13 @@ export async function classifyRoute(userMessage, agents, gateway) {
     const specialists = agents.filter(a => a.slug !== 'clementine');
     if (specialists.length === 0)
         return null;
+    if (hasNoDelegationInstruction(userMessage)) {
+        return {
+            targetAgent: 'clementine',
+            confidence: 0.95,
+            reasoning: 'User explicitly asked not to delegate or route this away from Clementine.',
+        };
+    }
     // Direct-imperative guardrail: user is instructing Clementine to act —
     // do not delegate, even if an agent is named.
     const imperative = isDirectImperative(userMessage);
@@ -272,7 +295,9 @@ export async function classifyRoute(userMessage, agents, gateway) {
         const wordRe = new RegExp(`\\b(${firstName}|${a.slug})\\b`, 'i');
         if (!wordRe.test(trimmed))
             continue;
-        if (isAskingAboutAgent(trimmed, firstName, a.slug)) {
+        const explicitDelegation = isExplicitDelegationToAgent(trimmed, firstName, a.slug);
+        const vocativeAddress = isVocativeAgentAddress(trimmed, firstName, a.slug);
+        if (!explicitDelegation && !vocativeAddress && isAskingAboutAgent(trimmed, firstName, a.slug)) {
             // The user is asking ABOUT the agent ("how is <agent> doing", "<agent>'s
             // tasks", "did <agent> handle that?") rather than addressing them. Fall
             // through to the LLM classifier, which has a system-prompt rule for
@@ -280,6 +305,8 @@ export async function classifyRoute(userMessage, agents, gateway) {
             logger.debug({ slug: a.slug, trigger: 'meta-mention-bypass' }, 'Routing skipped — name appears as topic, not vocative');
             continue;
         }
+        if (!explicitDelegation && !vocativeAddress)
+            continue;
         logger.debug({ slug: a.slug, trigger: 'explicit-mention' }, 'Fast-path routing decision');
         return {
             targetAgent: a.slug,

package/dist/agent/toolsets.d.ts

@@ -0,0 +1,14 @@
+export type ToolsetName = 'auto' | 'safe' | 'diagnostic' | 'communications' | 'memory' | 'full';
+export interface ToolsetPreset {
+    name: ToolsetName;
+    label: string;
+    description: string;
+    directive: string;
+}
+export declare const TOOLSET_PRESETS: readonly ToolsetPreset[];
+export declare function normalizeToolsetName(input: string | undefined | null): ToolsetName | null;
+export declare function getToolsetPreset(name: ToolsetName): ToolsetPreset;
+export declare function formatToolsetChoices(): string;
+export declare function isRestrictedToolset(name: ToolsetName): boolean;
+export declare function toolsetAllowsLocalWrites(name: ToolsetName): boolean;
+//# sourceMappingURL=toolsets.d.ts.map

package/dist/agent/toolsets.js

@@ -0,0 +1,68 @@
+export const TOOLSET_PRESETS = [
+    {
+        name: 'auto',
+        label: 'Auto',
+        description: 'Route to the smallest inferred tool surface for each turn.',
+        directive: '',
+    },
+    {
+        name: 'safe',
+        label: 'Safe',
+        description: 'Memory and read-only local context; no external sends or local writes.',
+        directive: 'Toolset safe: use memory and read-only local context. Do not send messages, email, delete data, deploy, or modify files unless the user switches toolsets.',
+    },
+    {
+        name: 'diagnostic',
+        label: 'Diagnostic',
+        description: 'Bounded logs, local reads, memory, and diagnostics; no external sends.',
+        directive: 'Toolset diagnostic: diagnose with bounded reads and capped command output. Prefer targeted log slices, summaries, and transcript_search. Do not send external messages or make product changes.',
+    },
+    {
+        name: 'communications',
+        label: 'Communications',
+        description: 'Email/message workflows plus memory; avoid code and deployment tools.',
+        directive: 'Toolset communications: focus on email, calendar, messaging, approvals, and memory continuity. Do not edit code, deploy, or run unrelated local commands.',
+    },
+    {
+        name: 'memory',
+        label: 'Memory',
+        description: 'Memory, transcript, and relationship tools only unless explicitly changed.',
+        directive: 'Toolset memory: use memory_read, memory_search, memory_recall, transcript_search, working_memory, and user_model. Avoid external integrations and local shell/file writes.',
+    },
+    {
+        name: 'full',
+        label: 'Full',
+        description: 'Explicit operator mode for broad integrations and admin work.',
+        directive: 'Toolset full: the user explicitly enabled the broad operator surface for this chat. Still keep tool output bounded and ask before destructive or irreversible actions.',
+    },
+];
+const TOOLSET_BY_NAME = new Map(TOOLSET_PRESETS.map((preset) => [preset.name, preset]));
+export function normalizeToolsetName(input) {
+    const value = String(input ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '-');
+    if (!value)
+        return null;
+    if (value === 'diagnostics' || value === 'debug')
+        return 'diagnostic';
+    if (value === 'comm' || value === 'comms' || value === 'communication')
+        return 'communications';
+    if (value === 'mem')
+        return 'memory';
+    if (value === 'all' || value === 'operator')
+        return 'full';
+    return TOOLSET_BY_NAME.has(value) ? value : null;
+}
+export function getToolsetPreset(name) {
+    return TOOLSET_BY_NAME.get(name) ?? TOOLSET_BY_NAME.get('auto');
+}
+export function formatToolsetChoices() {
+    return TOOLSET_PRESETS
+        .map((preset) => `- ${preset.name}: ${preset.description}`)
+        .join('\n');
+}
+export function isRestrictedToolset(name) {
+    return name === 'safe' || name === 'diagnostic' || name === 'memory';
+}
+export function toolsetAllowsLocalWrites(name) {
+    return name === 'auto' || name === 'full';
+}
+//# sourceMappingURL=toolsets.js.map

package/dist/brain/ingestion-pipeline.d.ts

@@ -32,6 +32,13 @@ export interface IngestResult {
     recordsWritten: number;
     recordsSkipped: number;
     recordsFailed: number;
+    recordsUnchanged: number;
+    recallCheckStatus?: 'ok' | 'partial' | 'skipped';
+    recallCheck?: {
+        checked: number;
+        hits: number;
+        missing: string[];
+    };
     errors: Array<{
         externalId?: string;
         error: string;

package/dist/brain/ingestion-pipeline.js

@@ -10,7 +10,7 @@
  *     → tag provenance → ingested_rows (structured overlay)
  *     → graph extractor → ingestion_runs audit
  */
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { VAULT_DIR } from '../config.js';
 import { getStore } from '../tools/shared.js';
@@ -33,6 +33,8 @@ export async function runIngestion(opts) {
     let recordsWritten = 0;
     let recordsSkipped = 0;
     let recordsFailed = 0;
+    let recordsUnchanged = 0;
+    const touchedExternalIds = new Set();
     const report = (stage, message) => {
         opts.onProgress?.({
             runId: runId ?? -1,
@@ -52,6 +54,14 @@ export async function runIngestion(opts) {
             recordsWritten += 1;
             if (sum)
                 writtenSummaries.push(sum);
+            if (sum?.externalId)
+                touchedExternalIds.add(sum.externalId);
+        },
+        onUnchanged: (sum) => {
+            recordsSkipped += 1;
+            recordsUnchanged += 1;
+            if (sum?.externalId)
+                touchedExternalIds.add(sum.externalId);
         },
         onSkip: () => { recordsSkipped += 1; },
         onFail: (err) => { recordsFailed += 1; errors.push(err); },
@@ -145,12 +155,28 @@ export async function runIngestion(opts) {
                 });
             }
         }
+        let recallCheckStatus = 'skipped';
+        let recallCheck;
+        if (!opts.dryRun && touchedExternalIds.size > 0) {
+            const missing = [];
+            for (const externalId of touchedExternalIds) {
+                if (!store.findChunkByExternalId(source.slug, externalId))
+                    missing.push(externalId);
+            }
+            recallCheck = {
+                checked: touchedExternalIds.size,
+                hits: touchedExternalIds.size - missing.length,
+                missing,
+            };
+            recallCheckStatus = missing.length === 0 ? 'ok' : 'partial';
+        }
         // Finalize
         const status = recordsFailed > 0 && recordsWritten === 0 ? 'error' :
             recordsFailed > 0 ? 'partial' : 'ok';
         if (runId !== null) {
             store.updateIngestionRun(runId, {
-                recordsIn, recordsWritten, recordsSkipped, recordsFailed,
+                recordsIn, recordsWritten, recordsSkipped, recordsFailed, recordsUnchanged,
+                recallCheckStatus,
                 errorsJson: errors.length ? JSON.stringify(errors.slice(0, 50)) : null,
                 overviewNotePath,
                 status,
@@ -165,6 +191,9 @@ export async function runIngestion(opts) {
             recordsWritten,
             recordsSkipped,
             recordsFailed,
+            recordsUnchanged,
+            recallCheckStatus,
+            recallCheck,
             errors,
             plannedRecords: opts.dryRun ? plannedRecords : undefined,
             overviewNotePath,
@@ -176,6 +205,7 @@ export async function runIngestion(opts) {
         if (runId !== null) {
             store.updateIngestionRun(runId, {
                 recordsIn, recordsWritten, recordsSkipped, recordsFailed: recordsFailed + 1,
+                recordsUnchanged,
                 errorsJson: JSON.stringify(errors),
                 status: 'error',
                 finished: true,
@@ -189,6 +219,8 @@ export async function runIngestion(opts) {
             recordsWritten,
             recordsSkipped,
             recordsFailed: recordsFailed + 1,
+            recordsUnchanged,
+            recallCheckStatus: 'skipped',
             errors,
             plannedRecords: opts.dryRun ? plannedRecords : undefined,
         };
@@ -207,8 +239,11 @@ async function processStructured(record, mapping, source, opts, store, _report,
             counters.onWrite(summaryBundle);
             return;
         }
-        await writeRecord(ingested, source, store);
-        counters.onWrite(summaryBundle);
+        const outcome = await writeRecord(ingested, source, store);
+        if (outcome === 'unchanged')
+            counters.onUnchanged(summaryBundle);
+        else
+            counters.onWrite(summaryBundle);
     }
     catch (err) {
         counters.onFail({ externalId: record.externalId, error: err instanceof Error ? err.message : String(err) });
@@ -242,8 +277,11 @@ async function processFreeForm(record, source, opts, store, report, planned, _er
             counters.onWrite(summaryBundle);
             return;
         }
-        await writeRecord(ingested, source, store);
-        counters.onWrite(summaryBundle);
+        const outcome = await writeRecord(ingested, source, store);
+        if (outcome === 'unchanged')
+            counters.onUnchanged(summaryBundle);
+        else
+            counters.onWrite(summaryBundle);
     }
     catch (err) {
         counters.onFail({ externalId: record.externalId, error: err instanceof Error ? err.message : String(err) });
@@ -266,37 +304,84 @@ async function writeRecord(record, source, store) {
             record.tags = [...record.tags, `project:${projSlug}`];
         }
     }
-    // 1) Raw payload → artifact store
-    const artifactId = store.storeArtifact({
-        toolName: `ingest:${source.slug}`,
-        summary: record.title || record.externalId,
-        content: record.rawPayload,
-        tags: [source.slug, sourceType, ...record.tags].join(','),
-        sessionKey: null,
-        agentSlug: source.agentSlug ?? null,
-    });
-    record.artifactId = artifactId;
-    // 2) Vault note: write markdown file with frontmatter + body
+    // 1) Vault note content. Build this before artifact writes so exact re-runs
+    // can be classified as unchanged without duplicating audit blobs.
     const abs = path.join(VAULT_DIR, record.targetRelPath);
     const dir = path.dirname(abs);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
+    if (existsSync(abs) && record.frontmatter && 'ingested_at' in record.frontmatter) {
+        try {
+            const current = readFileSync(abs, 'utf-8');
+            const match = current.match(/^ingested_at:\s*(.+)$/m);
+            if (match?.[1]) {
+                const raw = match[1].trim();
+                try {
+                    record.frontmatter.ingested_at = JSON.parse(raw);
+                }
+                catch {
+                    record.frontmatter.ingested_at = raw.replace(/^['"]|['"]$/g, '');
+                }
+            }
+        }
+        catch {
+            // Fall through with a fresh timestamp if the old note can't be read.
+        }
+    }
     const fm = { title: record.title, ...record.frontmatter };
     const frontmatterBlock = Object.entries(fm)
         .map(([k, v]) => `${k}: ${serializeYaml(v)}`)
         .join('\n');
     const fileContent = `---\n${frontmatterBlock}\n---\n\n# ${record.title}\n\n${record.body}\n`;
+    if (existsSync(abs)) {
+        try {
+            const current = readFileSync(abs, 'utf-8');
+            if (current === fileContent && store.findChunkByExternalId(record.sourceSlug, record.externalId)) {
+                store.recordMemoryEvent?.({
+                    sourceType: 'ingestion',
+                    sourceId: null,
+                    sessionKey: null,
+                    agentSlug: source.agentSlug ?? null,
+                    content: `${record.sourceSlug}:${record.externalId}\nunchanged\n${record.summary}`,
+                    indexed: true,
+                });
+                return 'unchanged';
+            }
+        }
+        catch {
+            // If the existing file can't be read, fall through and rewrite.
+        }
+    }
+    // 2) Raw payload → artifact store
+    const artifactId = store.storeArtifact({
+        toolName: `ingest:${source.slug}`,
+        summary: record.title || record.externalId,
+        content: record.rawPayload,
+        tags: [source.slug, sourceType, ...record.tags].join(','),
+        sessionKey: null,
+        agentSlug: source.agentSlug ?? null,
+    });
+    record.artifactId = artifactId;
+    // 3) Vault note: write markdown file with frontmatter + body
     writeFileSync(abs, fileContent, 'utf-8');
-    // 3) Re-index via existing vault pipeline (chunks, FTS, wikilinks)
+    // 4) Re-index via existing vault pipeline (chunks, FTS, wikilinks)
     store.updateFile(record.targetRelPath, source.agentSlug ?? undefined);
-    // 4) Tag provenance on the chunks we just wrote
+    // 5) Tag provenance on the chunks we just wrote
     store.tagChunksForSource(record.targetRelPath, {
         sourceSlug: record.sourceSlug,
         externalId: record.externalId,
         sourceType,
         lastSyncedAt: nowIso,
     });
-    // 5) Structured overlay for SQL aggregates
+    store.recordMemoryEvent?.({
+        sourceType: 'ingestion',
+        sourceId: artifactId,
+        sessionKey: null,
+        agentSlug: source.agentSlug ?? null,
+        content: `${record.sourceSlug}:${record.externalId}\n${record.title}\n${record.summary}`,
+        indexed: true,
+    });
+    // 6) Structured overlay for SQL aggregates
     if (record.structuredRow) {
         const chunkRef = store.findChunkByExternalId(record.sourceSlug, record.externalId);
         store.insertIngestedRow({
@@ -308,8 +393,9 @@ async function writeRecord(record, source, store) {
             structuredColumns: Object.fromEntries(Object.entries(record.structuredRow).map(([k, v]) => [k, coerceCol(v)])),
         });
     }
-    // 6) Graph (best-effort, no-op if graph unavailable)
+    // 7) Graph (best-effort, no-op if graph unavailable)
     await writeGraphForRecord(record);
+    return 'written';
 }
 async function applyStructuredColumns(mapping) {
     const store = await getStore();

package/dist/channels/discord.js

@@ -13,6 +13,8 @@ import path from 'node:path';
 import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, formatCronEmbed, rehydrateStatusEmbed, setSavedStatusEmbed, } from './discord-utils.js';
 import { DISCORD_TOKEN, DISCORD_OWNER_ID, DISCORD_WATCHED_CHANNELS, MODELS, ASSISTANT_NAME, OWNER_NAME, PKG_DIR, VAULT_DIR, BASE_DIR, DEFAULT_MODEL_TIER, } from '../config.js';
 import { findProjectByName, getLinkedProjects } from '../agent/assistant.js';
+import { detectApprovalReply } from '../agent/local-turn.js';
+import { normalizeToolsetName } from '../agent/toolsets.js';
 import * as cronParser from 'cron-parser';
 const logger = pino({ name: 'clementine.discord' });
 const BOT_MESSAGE_TRACKING_LIMIT = 100;
@@ -35,6 +37,12 @@ const slashCommands = [
         .addStringOption(o => o.setName('job').setDescription('Job name (for run/enable/disable)').setAutocomplete(true)),
     new SlashCommandBuilder().setName('heartbeat').setDescription('Run heartbeat check manually'),
     new SlashCommandBuilder().setName('tools').setDescription('List available MCP tools'),
+    new SlashCommandBuilder().setName('toolset').setDescription('Set this chat tool mode')
+        .addStringOption(o => o.setName('mode').setDescription('Tool mode').setRequired(true)
+        .addChoices({ name: 'Auto', value: 'auto' }, { name: 'Safe', value: 'safe' }, { name: 'Diagnostic', value: 'diagnostic' }, { name: 'Communications', value: 'communications' }, { name: 'Memory', value: 'memory' }, { name: 'Full', value: 'full' })),
+    new SlashCommandBuilder().setName('compress').setDescription('Compact this conversation context into memory'),
+    new SlashCommandBuilder().setName('usage').setDescription('Show recent turn/tool usage for this chat'),
+    new SlashCommandBuilder().setName('debug').setDescription('Show session diagnostics for this chat'),
     new SlashCommandBuilder().setName('project').setDescription('Set active project context')
         .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
         .addChoices({ name: 'List projects', value: 'list' }, { name: 'Set active project', value: 'set' }, { name: 'Clear active project', value: 'clear' }, { name: 'Show current', value: 'status' }))
@@ -269,6 +277,8 @@ function handleHelp() {
         '`!self-improve run|status|history|pending|apply|deny` \u2014 Self-improvement',
         '`!team setup|list|status|messages|topology` \u2014 Manage agent team',
         '`!status [job]` \u2014 Check unleashed task progress',
+        '`/toolset` \u2014 Set tool mode \u00b7 `/compress` \u2014 Compact context \u00b7 `/usage` \u2014 Usage snapshot',
+        '`/debug` \u2014 Session diagnostics',
         '`!dashboard` \u2014 Send a fresh system status embed',
         '`!heartbeat` \u2014 Run heartbeat \u00b7 `!tools` \u2014 List tools \u00b7 `!clear` \u2014 Reset',
         '`!stop` \u2014 Interrupt current response',
@@ -1074,15 +1084,12 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
             }
             // ── Approval responses (DM only) ────────────────────────────────
             if (isDm) {
-                const lower = text.toLowerCase();
-                if (['yes', 'no', 'approve', 'deny', 'go', 'skip', 'always'].includes(lower)) {
+                const approvalReply = detectApprovalReply(text);
+                if (approvalReply !== null) {
                     const approvals = gateway.getPendingApprovals();
                     if (approvals.length > 0) {
-                        // Pass 'always' as a string so the check-in gate can persist the channel
-                        const result = lower === 'always' ? 'always' :
-                            (lower === 'yes' || lower === 'approve' || lower === 'go');
-                        gateway.resolveApproval(approvals[approvals.length - 1], result);
-                        await message.react(lower === 'no' || lower === 'deny' || lower === 'skip' ? '\u274c' : '\u2705');
+                        gateway.resolveApproval(approvals[approvals.length - 1], approvalReply);
+                        await message.react(approvalReply === false ? '\u274c' : '\u2705');
                         return;
                     }
                 }
@@ -1227,6 +1234,30 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                     await cmd.reply(formatToolsList());
                     return;
                 }
+                if (name === 'toolset') {
+                    const mode = normalizeToolsetName(cmd.options.getString('mode', true));
+                    if (!mode) {
+                        await cmd.reply({ content: 'Unknown toolset.', ephemeral: true });
+                        return;
+                    }
+                    gateway.setSessionToolset(sessionKey, mode);
+                    await cmd.reply({ content: `Toolset set to **${mode}**.`, ephemeral: true });
+                    updatePresence(sessionKey);
+                    return;
+                }
+                if (name === 'compress') {
+                    await cmd.reply({ content: gateway.compactSessionForUser(sessionKey), ephemeral: true });
+                    updatePresence(sessionKey);
+                    return;
+                }
+                if (name === 'usage') {
+                    await cmd.reply({ content: gateway.describeSessionUsage(sessionKey), ephemeral: true });
+                    return;
+                }
+                if (name === 'debug') {
+                    await cmd.reply({ content: gateway.describeSessionDebug(sessionKey).slice(0, 1900), ephemeral: true });
+                    return;
+                }
                 if (name === 'status') {
                     const jobArg = cmd.options.getString('job') ?? undefined;
                     await cmd.reply(handleUnleashedStatus(jobArg));

package/dist/channels/telegram.js

@@ -7,6 +7,7 @@
 import { Bot } from 'grammy';
 import pino from 'pino';
 import { TELEGRAM_BOT_TOKEN, TELEGRAM_OWNER_ID, } from '../config.js';
+import { detectApprovalReply } from '../agent/local-turn.js';
 const logger = pino({ name: 'clementine.telegram' });
 const STREAM_UPDATE_INTERVAL = 1500; // ms
 const TELEGRAM_MSG_LIMIT = 4096;
@@ -139,14 +140,12 @@ export async function startTelegram(gateway, dispatcher) {
         const chatId = ctx.chat.id;
         const sessionKey = `telegram:user:${userId}`;
         // ── Approval responses ──────────────────────────────────────────
-        const lower = text.toLowerCase().trim();
-        if (['yes', 'no', 'approve', 'deny', 'go', 'skip', 'always'].includes(lower)) {
+        const approvalReply = detectApprovalReply(text);
+        if (approvalReply !== null) {
             const approvals = gateway.getPendingApprovals();
             if (approvals.length > 0) {
-                const result = lower === 'always' ? 'always' :
-                    (lower === 'yes' || lower === 'approve' || lower === 'go');
-                gateway.resolveApproval(approvals[approvals.length - 1], result);
-                const approved = result !== false;
+                gateway.resolveApproval(approvals[approvals.length - 1], approvalReply);
+                const approved = approvalReply !== false;
                 await ctx.reply(approved ? '✅ Approved.' : '❌ Denied.');
                 return;
             }