clementine-agent 1.0.25 → 1.0.27

package/dist/agent/assistant.d.ts

@@ -186,7 +186,7 @@ export declare class PersonalAssistant {
         };
         delegateProfile?: AgentProfile;
     }): Promise<string>;
-    runCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, timeoutMs?: number, successCriteria?: string[]): Promise<string>;
+    runCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, timeoutMs?: number, successCriteria?: string[], agentSlug?: string): Promise<string>;
     /**
      * Goal-backward verification pass using Haiku after cron job execution.
      * Instead of vague quality ratings, verifies actual outcomes:
@@ -195,7 +195,7 @@ export declare class PersonalAssistant {
      * 3. Does it connect to the goal / produce actionable results? (wired)
      */
     private runCronReflection;
-    runUnleashedTask(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, maxHours?: number): Promise<string>;
+    runUnleashedTask(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, maxHours?: number, agentSlug?: string): Promise<string>;
     /**
      * Run a team message as an unleashed-style autonomous task.
      * Gives team agents the same multi-phase execution as cron jobs,
@@ -203,7 +203,7 @@ export declare class PersonalAssistant {
      *
      * @param onText  Streaming callback for real-time progress updates
      */
-    runTeamTask(fromName: string, fromSlug: string, content: string, profile: AgentProfile, onText?: (token: string) => void): Promise<string>;
+    runTeamTask(fromName: string, fromSlug: string, content: string, profile: AgentProfile, onText?: (token: string) => void, externalAbortController?: AbortController): Promise<string>;
     /**
      * Inject a user/assistant exchange into a session's context without running
      * a query.  Used to give the DM session visibility of cron/heartbeat outputs

package/dist/agent/assistant.js

@@ -1302,11 +1302,16 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 : isCron && !isUnleashed ? 'medium'
                     : isPlanStep || isUnleashed ? 'high'
                         : undefined);
-        // ── Compute budget cap ────────────────────────────────────────
+        // ── Compute budget (telemetry only) ───────────────────────────
+        // Cost is informational on a Claude subscription — killing a job
+        // mid-phase because it hit $5 in tokens is worse than the cost.
+        // We still compute the figure so dashboards/logs can show it, but
+        // do not pass it into the SDK as an enforcement knob.
         const computedBudget = maxBudgetUsd ?? (isHeartbeat && !isCron ? BUDGET.heartbeat
             : isCron && (cronTier ?? 0) < 2 ? BUDGET.cronT1
                 : isCron ? BUDGET.cronT2
                     : BUDGET.chat);
+        void computedBudget; // reserved for future cost telemetry — not enforced
         // ── Compute adaptive thinking ─────────────────────────────────
         const supportsThinking = !resolvedModel.includes('haiku');
         const needsThinking = !isHeartbeat && (isPlanStep || isUnleashed || !isCron);
@@ -1355,7 +1360,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             cwd: BASE_DIR,
             env: SAFE_ENV,
             ...(computedEffort ? { effort: computedEffort } : {}),
-            ...(computedBudget !== undefined ? { maxBudgetUsd: computedBudget } : {}),
+            // maxBudgetUsd intentionally omitted — see comment above.
             ...(computedThinking ? { thinking: computedThinking } : {}),
             ...(computedBetas ? { betas: computedBetas } : {}),
             ...(outputFormat ? { outputFormat } : {}),
@@ -2994,8 +2999,11 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         return extractDeliverable(trace) ||
             trace.filter(t => t.type === 'text').map(t => t.content).join('').trim();
     }
-    async runCronJob(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, timeoutMs, successCriteria) {
+    async runCronJob(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, timeoutMs, successCriteria, agentSlug) {
         setInteractionSource('autonomous');
+        const cronProfile = agentSlug && agentSlug !== 'clementine'
+            ? this.profileManager.get(agentSlug)
+            : null;
         const cronGuard = new StallGuard();
         const sdkOptions = this.buildOptions({
             isHeartbeat: true,
@@ -3004,6 +3012,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             model: model ?? null,
             enableTeams: true,
             stallGuard: cronGuard,
+            profile: cronProfile,
         });
         // Override cwd if a project workDir is specified
         if (workDir) {
@@ -3406,8 +3415,11 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
     }
     // ── Unleashed Mode (Long-Running Autonomous Tasks) ─────────────────
-    async runUnleashedTask(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, maxHours) {
+    async runUnleashedTask(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, maxHours, agentSlug) {
         setInteractionSource('autonomous');
+        const unleashedProfile = agentSlug && agentSlug !== 'clementine'
+            ? this.profileManager.get(agentSlug)
+            : null;
         const effectiveMaxHours = maxHours ?? UNLEASHED_DEFAULT_MAX_HOURS;
         const turnsPerPhase = maxTurns ?? UNLEASHED_PHASE_TURNS;
         const deadline = Date.now() + effectiveMaxHours * 60 * 60 * 1000;
@@ -3478,6 +3490,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 isUnleashed: true,
                 maxBudgetUsd: BUDGET.unleashedPhase,
                 stallGuard: phaseGuard,
+                profile: unleashedProfile,
             });
             // Enable progress summaries for real-time status updates
             sdkOptions.agentProgressSummaries = true;
@@ -3796,7 +3809,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
      *
      * @param onText  Streaming callback for real-time progress updates
      */
-    async runTeamTask(fromName, fromSlug, content, profile, onText) {
+    async runTeamTask(fromName, fromSlug, content, profile, onText, externalAbortController) {
         setInteractionSource('autonomous');
         const taskName = `team-msg:${fromSlug}-to-${profile.slug}`;
         const maxHours = 1; // Team messages get 1 hour max (not 6 like cron unleashed)
@@ -3808,6 +3821,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         let lastOutput = '';
         let consecutiveErrors = 0;
         while (phase < maxPhases) {
+            if (externalAbortController?.signal.aborted) {
+                logger.info({ taskName, phase }, 'Team task aborted by caller');
+                return lastOutput || `Team task aborted by caller at phase ${phase}.`;
+            }
             if (Date.now() >= deadline) {
                 logger.info({ taskName, phase }, 'Team task timed out');
                 return lastOutput || `Team task timed out after ${maxHours}h at phase ${phase}.`;
@@ -3878,6 +3895,17 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 phaseAc.abort();
                 logger.warn({ taskName, phase }, `Team task phase ${phase} aborted — deadline reached`);
             }, Math.max(deadline - Date.now(), 0));
+            // Propagate external abort (e.g., user sent "Stop") into the phase controller
+            const onExternalAbort = () => {
+                phaseAc.abort();
+                logger.info({ taskName, phase }, `Team task phase ${phase} aborted by caller`);
+            };
+            if (externalAbortController) {
+                if (externalAbortController.signal.aborted)
+                    phaseAc.abort();
+                else
+                    externalAbortController.signal.addEventListener('abort', onExternalAbort, { once: true });
+            }
             sdkOptions.abortController = phaseAc;
             try {
                 const stream = query({ prompt, options: sdkOptions });
@@ -3933,6 +3961,13 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             }
             catch (err) {
                 clearTimeout(phaseTimer);
+                externalAbortController?.signal.removeEventListener('abort', onExternalAbort);
+                // If this phase aborted because the caller cancelled, return cleanly —
+                // no retry, no 3-strikes counter.
+                if (externalAbortController?.signal.aborted) {
+                    logger.info({ taskName, phase }, 'Team task aborted mid-phase by caller');
+                    return lastOutput || `Team task aborted by caller at phase ${phase}.`;
+                }
                 logger.error({ err, taskName, phase }, 'Team task phase error');
                 consecutiveErrors++;
                 if (consecutiveErrors >= 3) {
@@ -3942,6 +3977,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 continue;
             }
             clearTimeout(phaseTimer);
+            externalAbortController?.signal.removeEventListener('abort', onExternalAbort);
             sessionId = phaseSessionId;
             lastOutput = phaseOutput.trim();
             consecutiveErrors = 0;

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

@@ -23,6 +23,10 @@ export interface RouteDecision {
     confidence: number;
     reasoning: string;
 }
+export declare function isDirectImperative(userMessage: string): {
+    match: boolean;
+    pattern?: string;
+};
 /**
  * Session keys eligible for routing. Any key NOT in this set is
  * considered agent-scoped or system-scoped and never routes.

package/dist/agent/route-classifier.js

@@ -18,6 +18,36 @@
  */
 import pino from 'pino';
 const logger = pino({ name: 'clementine.route-classifier' });
+/**
+ * Direct-imperative guardrail.
+ *
+ * When the user is explicitly instructing Clementine to do the work herself
+ * — "I need you to…", "you need to…", "use the CLI…", "stop/wait" —
+ * routing to a specialist is almost always wrong. The user knows who they
+ * are talking to and is asking *her* to act. Delegating here produces the
+ * "every message spawns a team task" cascade that leaves the user waiting
+ * and shouting "Stop".
+ *
+ * This check runs before the LLM classifier and the explicit-mention fast
+ * path, so even "Nora, I need you to do X" stays with Clementine when Nate
+ * is DMing Clementine (the `isRoutable` gate already guarantees the session
+ * belongs to Clementine).
+ */
+const DIRECT_IMPERATIVE_PATTERNS = [
+    /\bi (need|want|would like) you to\b/i,
+    /\byou (need to|should|gotta|have to|must)\b/i,
+    /\b(please )?(use|run|execute|call|invoke|query|check|pull|grab|fetch|look up|lookup|search) (the )?(sf|salesforce|cli|bash|sdk|api|db|database)\b/i,
+    /^(stop|wait|hold on|nevermind|never mind|cancel)\b/i,
+];
+export function isDirectImperative(userMessage) {
+    const text = userMessage.trim();
+    for (const re of DIRECT_IMPERATIVE_PATTERNS) {
+        const m = text.match(re);
+        if (m)
+            return { match: true, pattern: m[0] };
+    }
+    return { match: false };
+}
 /**
  * Session keys eligible for routing. Any key NOT in this set is
  * considered agent-scoped or system-scoped and never routes.
@@ -156,6 +186,13 @@ export async function classifyRoute(userMessage, agents, gateway) {
     const specialists = agents.filter(a => a.slug !== 'clementine');
     if (specialists.length === 0)
         return null;
+    // Direct-imperative guardrail: user is instructing Clementine to act —
+    // do not delegate, even if an agent is named.
+    const imperative = isDirectImperative(userMessage);
+    if (imperative.match) {
+        logger.info({ pattern: imperative.pattern }, 'Routing skipped — direct imperative');
+        return null;
+    }
     // Fast path: explicit slug mention anywhere in the message.
     for (const a of specialists) {
         const nameLower = a.name.toLowerCase();

package/dist/channels/discord-agent-bot.d.ts

@@ -76,8 +76,6 @@ export declare class AgentBotClient {
     sendDmTo(userId: string, text: string, embed?: EmbedBuilder): Promise<void>;
     /** Send a message to a specific channel via this agent bot. */
     sendToChannel(channelId: string, text: string, embed?: EmbedBuilder): Promise<void>;
-    /** Send a startup status embed to the owner's DMs. */
-    private sendStartupStatus;
     private buildAgentStatusEmbed;
     private sendOrUpdateStatusEmbed;
     /**

package/dist/channels/discord-agent-bot.js

@@ -14,7 +14,7 @@
  */
 import { ActionRowBuilder, ActivityType, ChannelType, Client, EmbedBuilder, Events, GatewayIntentBits, ModalBuilder, Partials, REST, Routes, SlashCommandBuilder, TextInputBuilder, TextInputStyle, } from 'discord.js';
 import pino from 'pino';
-import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, sanitizeResponse } from './discord-utils.js';
+import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, sanitizeResponse, rehydrateStatusEmbed, setSavedStatusEmbed } from './discord-utils.js';
 import { MODELS } from '../config.js';
 import * as cronParser from 'cron-parser';
 const logger = pino({ name: 'clementine.agent-bot' });
@@ -124,10 +124,14 @@ export class AgentBotClient {
                         type: ActivityType.Custom,
                     }],
             });
-            // Send startup status to owner's DMs
-            await this.sendStartupStatus();
-            // Send status embed to the agent's primary channel (if available)
+            // Intentionally NOT sending a startup DM. The main Clementine bot
+            // already posts a consolidated "here's who's online" embed in the
+            // owner DM, so per-agent DMs on every restart are pure noise.
+            // Send status embed to the agent's primary channel (if available).
+            // Rehydrate any prior embed first so we edit-in-place instead of
+            // posting a fresh pinned message on every restart.
             if (this.config.cronScheduler && this.resolvedChannelIds.length > 0) {
+                this.statusEmbedMessage = await rehydrateStatusEmbed(this.client, this.config.slug);
                 await this.sendOrUpdateStatusEmbed();
                 // Auto-update status embed on state changes (debounced)
                 this.config.cronScheduler.onStatusChange(() => {
@@ -289,30 +293,6 @@ export class AgentBotClient {
             }
         }
     }
-    /** Send a startup status embed to the owner's DMs. */
-    async sendStartupStatus() {
-        if (!this.config.ownerId)
-            return;
-        try {
-            const owner = await this.client.users.fetch(this.config.ownerId, { force: true });
-            const dmChannel = await owner.createDM();
-            // Use the rich agent status embed if cronScheduler is available
-            const embed = this.config.cronScheduler
-                ? this.buildAgentStatusEmbed()
-                : new EmbedBuilder()
-                    .setColor(0x22c55e)
-                    .setTitle(`${this.config.profile.name} is online`)
-                    .setDescription(this.config.profile.description)
-                    .addFields({ name: 'Model', value: this.config.profile.model || 'sonnet', inline: true }, { name: 'Tier', value: String(this.config.profile.tier), inline: true })
-                    .setFooter({ text: `Agent bot \u00b7 ${this.client.user?.tag ?? 'unknown'}` })
-                    .setTimestamp();
-            await dmChannel.send({ embeds: [embed] });
-            logger.info({ slug: this.config.slug }, 'Sent startup status embed to owner DMs');
-        }
-        catch (err) {
-            logger.error({ err, slug: this.config.slug }, 'Failed to send startup status embed');
-        }
-    }
     // ── Agent-scoped status embed ──────────────────────────────────────
     buildAgentStatusEmbed() {
         const now = new Date();
@@ -454,6 +434,11 @@ export class AgentBotClient {
                         await this.statusEmbedMessage.pin();
                     }
                     catch { /* may lack perms */ }
+                    // Persist so the next restart edits this same message instead of
+                    // posting another pinned copy.
+                    if (this.statusEmbedMessage) {
+                        setSavedStatusEmbed(this.config.slug, channelId, this.statusEmbedMessage.id);
+                    }
                 }
             }
         }
@@ -854,6 +839,9 @@ export class AgentBotClient {
                         await this.statusEmbedMessage.pin();
                     }
                     catch { /* non-fatal */ }
+                    if (this.statusEmbedMessage) {
+                        setSavedStatusEmbed(this.config.slug, message.channel.id, this.statusEmbedMessage.id);
+                    }
                 }
             }
             else {

package/dist/channels/discord-utils.d.ts

@@ -4,7 +4,19 @@
  * Extracted from discord.ts so agent bot clients can reuse streaming,
  * chunking, and sanitization without importing the monolith.
  */
-import { EmbedBuilder, type Message } from 'discord.js';
+import { EmbedBuilder, type Client, type Message } from 'discord.js';
+export declare function getSavedStatusEmbed(slug: string): {
+    channelId: string;
+    messageId: string;
+} | null;
+export declare function setSavedStatusEmbed(slug: string, channelId: string, messageId: string): void;
+export declare function clearSavedStatusEmbed(slug: string): void;
+/**
+ * Try to re-hydrate a previously-saved status embed message so that on
+ * restart the bot edits it in place instead of posting a fresh one.
+ * Returns the Message if still reachable, else null.
+ */
+export declare function rehydrateStatusEmbed(client: Client, slug: string): Promise<Message | null>;
 export declare const STREAM_EDIT_INTERVAL = 400;
 export declare const THINKING_INDICATOR = "\u2728 *thinking...*";
 export declare const DISCORD_MSG_LIMIT = 2000;

package/dist/channels/discord-utils.js

@@ -5,6 +5,70 @@
  * chunking, and sanitization without importing the monolith.
  */
 import { EmbedBuilder } from 'discord.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { BASE_DIR } from '../config.js';
+const utilsLogger = pino({ name: 'clementine.discord-utils' });
+// ── Persistent status-embed state ─────────────────────────────────────
+//
+// When the daemon restarts, in-memory references to status-embed messages
+// are lost, so the bots used to post a fresh pinned embed every time.
+// Persist (channelId, messageId) per slug so the next boot can fetch the
+// existing message and edit it in place — no restart ping spam.
+const STATUS_EMBED_STATE_FILE = path.join(BASE_DIR, '.agent-status-embeds.json');
+function loadStatusEmbedState() {
+    try {
+        if (!existsSync(STATUS_EMBED_STATE_FILE))
+            return {};
+        return JSON.parse(readFileSync(STATUS_EMBED_STATE_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveStatusEmbedState(state) {
+    try {
+        writeFileSync(STATUS_EMBED_STATE_FILE, JSON.stringify(state, null, 2));
+    }
+    catch (err) {
+        utilsLogger.debug({ err }, 'Failed to save status embed state (non-fatal)');
+    }
+}
+export function getSavedStatusEmbed(slug) {
+    const s = loadStatusEmbedState()[slug];
+    return s ?? null;
+}
+export function setSavedStatusEmbed(slug, channelId, messageId) {
+    const state = loadStatusEmbedState();
+    state[slug] = { channelId, messageId };
+    saveStatusEmbedState(state);
+}
+export function clearSavedStatusEmbed(slug) {
+    const state = loadStatusEmbedState();
+    delete state[slug];
+    saveStatusEmbedState(state);
+}
+/**
+ * Try to re-hydrate a previously-saved status embed message so that on
+ * restart the bot edits it in place instead of posting a fresh one.
+ * Returns the Message if still reachable, else null.
+ */
+export async function rehydrateStatusEmbed(client, slug) {
+    const saved = getSavedStatusEmbed(slug);
+    if (!saved)
+        return null;
+    try {
+        const channel = await client.channels.fetch(saved.channelId).catch(() => null);
+        if (!channel || !('messages' in channel))
+            return null;
+        const msg = await channel.messages.fetch(saved.messageId).catch(() => null);
+        return msg ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 export const STREAM_EDIT_INTERVAL = 400;
 export const THINKING_INDICATOR = '\u2728 *thinking...*';
 export const DISCORD_MSG_LIMIT = 2000;

package/dist/channels/discord.js

@@ -10,7 +10,7 @@ import pino from 'pino';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, formatCronEmbed, } from './discord-utils.js';
+import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, formatCronEmbed, rehydrateStatusEmbed, setSavedStatusEmbed, } from './discord-utils.js';
 import { DISCORD_TOKEN, DISCORD_OWNER_ID, DISCORD_WATCHED_CHANNELS, MODELS, ASSISTANT_NAME, PKG_DIR, VAULT_DIR, BASE_DIR, DEFAULT_MODEL_TIER, ENABLE_1M_CONTEXT, } from '../config.js';
 import { findProjectByName, getLinkedProjects } from '../agent/assistant.js';
 import * as cronParser from 'cron-parser';
@@ -62,6 +62,20 @@ const slashCommands = [
     new SlashCommandBuilder().setName('help').setDescription('Show all available commands'),
 ];
 const botMessageMap = new Map();
+/**
+ * Recognize short natural-language stop commands so the user doesn't have
+ * to remember the `!stop` slash syntax. Only matches short standalone
+ * messages (≤30 chars) so a longer message containing the word "stop" is
+ * not misread as an abort.
+ */
+function isStopCommand(text) {
+    const t = text.trim().toLowerCase().replace(/[.!?,]+$/g, '');
+    if (t === '!stop' || t === '/stop')
+        return true;
+    if (t.length > 30)
+        return false;
+    return /^(stop|cancel|nevermind|never mind|hold on|wait( (stop|up))?|pause|abort)$/.test(t);
+}
 function trackBotMessage(messageId, context) {
     botMessageMap.set(messageId, context);
     // Evict oldest entries to prevent memory leak
@@ -576,6 +590,11 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                     await statusEmbedMessage.pin();
                 }
                 catch { /* may already be pinned or lack perms */ }
+                // Persist so the next restart edits this message instead of posting another
+                const channelId = statusEmbedMessage?.channelId ?? target?.id;
+                if (channelId && statusEmbedMessage) {
+                    setSavedStatusEmbed('clementine', channelId, statusEmbedMessage.id);
+                }
             }
         }
         catch (err) {
@@ -599,6 +618,10 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                     await statusEmbedMessage.pin();
                 }
                 catch { /* non-fatal */ }
+                const channelId = statusEmbedMessage?.channelId ?? channel?.id;
+                if (channelId && statusEmbedMessage) {
+                    setSavedStatusEmbed('clementine', channelId, statusEmbedMessage.id);
+                }
             }
         }
         catch (err) {
@@ -621,16 +644,19 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
             logger.error({ err }, 'Failed to register slash commands');
         }
         updatePresence();
-        // Auto-send status embed to owner's DMs on startup
+        // Rehydrate + auto-update the owner-DM status embed. If a prior pinned
+        // embed is still reachable we edit it in place so restarts don't spam
+        // the owner's DM with fresh pinned messages.
         try {
             const owner = await client.users.fetch(DISCORD_OWNER_ID, { force: true });
             const dmChannel = await owner.createDM();
             cachedDmChannel = dmChannel;
+            statusEmbedMessage = await rehydrateStatusEmbed(client, 'clementine');
             await sendOrUpdateStatusEmbed(dmChannel);
-            logger.info('Sent startup status embed to owner DMs');
+            logger.info({ rehydrated: !!statusEmbedMessage }, 'Status embed ready for owner DM');
         }
         catch (err) {
-            logger.error({ err }, 'Failed to send startup status embed');
+            logger.error({ err }, 'Failed to prepare startup status embed');
         }
         // Event-driven embed updates — debounced to avoid API spam
         cronScheduler.onStatusChange(() => {
@@ -1078,8 +1104,12 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                 }
                 catch { /* referenced message may be deleted */ }
             }
-            // ── !stop — abort active query (bypasses session lock) ────────────
-            if (isDm && (text === '!stop' || text === '/stop')) {
+            // ── Stop command — abort active query + any in-flight team tasks ─
+            // Accept the canonical !stop/ /stop AND plain natural-language variants
+            // ("stop", "Stop", "Stop.", "cancel", "wait stop", "nevermind") that
+            // users actually type. Only triggers on short standalone messages so
+            // we don't accidentally abort a longer message that contains "stop".
+            if (isDm && isStopCommand(text)) {
                 const stopped = gateway.stopSession(sessionKey);
                 await message.reply(stopped ? 'Stopping...' : 'Nothing running to stop.');
                 return;

package/dist/gateway/cron-scheduler.js

@@ -854,12 +854,12 @@ export class CronScheduler {
                 const startedAt = new Date();
                 try {
                     // Standard cron jobs get a timeout via SDK AbortController (advisor may override)
-                    let response = await this.gateway.handleCronJob(job.name, jobPrompt, job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria);
+                    let response = await this.gateway.handleCronJob(job.name, jobPrompt, job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria, job.agentSlug);
                     // alwaysDeliver: retry once if the response is empty/noise
                     if (job.alwaysDeliver && (!response || CronScheduler.isCronNoise(response))) {
                         logger.info({ job: job.name }, 'alwaysDeliver: empty/noise response — retrying once');
                         try {
-                            const retryResponse = await this.gateway.handleCronJob(job.name, jobPrompt + '\n\nYou MUST produce a brief status update. Do NOT return __NOTHING__.', job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria);
+                            const retryResponse = await this.gateway.handleCronJob(job.name, jobPrompt + '\n\nYou MUST produce a brief status update. Do NOT return __NOTHING__.', job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria, job.agentSlug);
                             if (retryResponse && !CronScheduler.isCronNoise(retryResponse)) {
                                 response = retryResponse;
                             }
@@ -1563,7 +1563,10 @@ export class CronScheduler {
                         enriched: !!advice.promptEnrichment,
                     }, 'Goal work: advisor applied');
                     this.gateway.handleCronJob(jobName, enrichedPrompt, 2, effectiveMaxTurns, effectiveModel, undefined, // workDir
-                    useUnleashed ? 'unleashed' : undefined, useUnleashed ? 1 : undefined).then((result) => {
+                    useUnleashed ? 'unleashed' : undefined, useUnleashed ? 1 : undefined, // 1 hour max for unleashed goal work
+                    undefined, // timeoutMs (use default)
+                    undefined, // successCriteria
+                    ownerSlug ?? undefined).then((result) => {
                         if (result && !CronScheduler.isCronNoise(result)) {
                             this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`, dispatchOpts).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
                         }
@@ -1576,7 +1579,13 @@ export class CronScheduler {
                 }).catch((err) => {
                     // Advisor import failed — fall back to basic execution
                     logger.warn({ err, goalId: trigger.goalId }, 'Advisor unavailable — running goal work with defaults');
-                    this.gateway.handleCronJob(jobName, prompt, 2, trigger.maxTurns ?? 15).then((result) => {
+                    this.gateway.handleCronJob(jobName, prompt, 2, trigger.maxTurns ?? 15, undefined, // model
+                    undefined, // workDir
+                    undefined, // mode
+                    undefined, // maxHours
+                    undefined, // timeoutMs
+                    undefined, // successCriteria
+                    ownerSlug ?? undefined).then((result) => {
                         if (result && !CronScheduler.isCronNoise(result)) {
                             this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`, dispatchOpts).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
                         }

package/dist/gateway/router.d.ts

@@ -46,6 +46,12 @@ export declare class Gateway {
     private _saveSeenChannels;
     /** Mark a channel as seen (owner approved or explicitly always-allowed). */
     markChannelSeen(channelKey: string): void;
+    /**
+     * Resolve the agent slug for a session so cross-agent delivery stays in-persona.
+     * Prefers the explicit session profile (set by agent bots + cron-scheduler), then
+     * falls back to parsing the session-key format.
+     */
+    private _agentSlugFromSessionKey;
     /**
      * Deliver a deep-mode result back to the user.
      * Routes through the agent's session so it responds conversationally,
@@ -124,8 +130,8 @@ export declare class Gateway {
     clearSessionProfile(sessionKey: string): void;
     isSessionBusy(sessionKey: string): boolean;
     /**
-     * Abort an in-progress chat query for a session.
-     * Returns true if there was an active query to abort.
+     * Abort an in-progress chat query AND any in-flight delegated team tasks
+     * for this session. Returns true if anything was actually aborted.
      */
     stopSession(sessionKey: string): boolean;
     /**
@@ -138,13 +144,13 @@ export declare class Gateway {
     private acquireSessionLock;
     handleMessage(sessionKey: string, text: string, onText?: OnTextCallback, model?: string, maxTurns?: number, onToolActivity?: OnToolActivityCallback): Promise<string>;
     handleHeartbeat(standingInstructions: string, changesSummary?: string, timeContext?: string, dedupContext?: string, profile?: import('../types.js').AgentProfile | null): Promise<string>;
-    handleCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, mode?: 'standard' | 'unleashed', maxHours?: number, timeoutMs?: number, successCriteria?: string[]): Promise<string>;
+    handleCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, mode?: 'standard' | 'unleashed', maxHours?: number, timeoutMs?: number, successCriteria?: string[], agentSlug?: string): Promise<string>;
     /**
      * Process a team message as an autonomous task — same multi-phase execution
      * as cron unleashed jobs, so agents can work until done instead of being
      * killed by the 5-minute interactive chat timeout.
      */
-    handleTeamTask(fromName: string, fromSlug: string, content: string, profile: import('../types.js').AgentProfile, onText?: (token: string) => void): Promise<string>;
+    handleTeamTask(fromName: string, fromSlug: string, content: string, profile: import('../types.js').AgentProfile, onText?: (token: string) => void, abortController?: AbortController): Promise<string>;
     handlePlan(sessionKey: string, taskDescription: string, onProgress?: (updates: PlanProgressUpdate[]) => Promise<void>, onApproval?: (planSummary: string, steps: PlanStep[]) => Promise<boolean | string>): Promise<string>;
     handleWorkflow(workflow: WorkflowDefinition, inputs?: Record<string, string>): Promise<string>;
     /**

package/dist/gateway/router.js

@@ -175,6 +175,24 @@ export class Gateway {
         this._loadSeenChannels().add(channelKey);
         this._saveSeenChannels();
     }
+    /**
+     * Resolve the agent slug for a session so cross-agent delivery stays in-persona.
+     * Prefers the explicit session profile (set by agent bots + cron-scheduler), then
+     * falls back to parsing the session-key format.
+     */
+    _agentSlugFromSessionKey(sessionKey) {
+        const profile = this.getSessionProfile(sessionKey);
+        if (profile && profile !== 'clementine')
+            return profile;
+        const parts = sessionKey.split(':');
+        if (parts[0] !== 'discord')
+            return undefined;
+        if (parts[1] === 'agent' || parts[1] === 'member-dm')
+            return parts[2];
+        if ((parts[1] === 'channel' || parts[1] === 'member') && parts.length >= 5)
+            return parts[3];
+        return undefined;
+    }
     /**
      * Deliver a deep-mode result back to the user.
      * Routes through the agent's session so it responds conversationally,
@@ -182,17 +200,19 @@ export class Gateway {
      * Falls back to pushing rawResult directly if the agent call fails.
      */
     async _deliverDeepResult(sessionKey, syntheticPrompt, rawFallback) {
+        const agentSlug = this._agentSlugFromSessionKey(sessionKey);
+        const ctx = { sessionKey, ...(agentSlug ? { agentSlug } : {}) };
         try {
             const agentReply = await this.handleMessage(sessionKey, syntheticPrompt);
             if (agentReply?.trim()) {
-                await this._dispatcher?.send(agentReply, { sessionKey });
-                logger.info({ sessionKey }, 'Deep mode result delivered via agent follow-up + dispatcher');
+                await this._dispatcher?.send(agentReply, ctx);
+                logger.info({ sessionKey, agentSlug }, 'Deep mode result delivered via agent follow-up + dispatcher');
             }
         }
         catch (err) {
             logger.warn({ err, sessionKey }, 'Deep mode agent follow-up failed — using raw fallback');
             if (rawFallback.trim()) {
-                await this._dispatcher?.send(rawFallback.slice(0, 1500), { sessionKey })
+                await this._dispatcher?.send(rawFallback.slice(0, 1500), ctx)
                     .catch(async (e) => {
                     // Both paths failed — surface it instead of swallowing at debug level.
                     logger.warn({ err: e, sessionKey }, 'Deep mode fallback delivery failed — persisting to daily note');
@@ -239,16 +259,30 @@ export class Gateway {
                 // Fire the team task in the background; ack immediately.
                 const ackMessage = `Routing this to **${targetProfile.name}** (${decision.reasoning.toLowerCase()}). I'll post their response back here when done.`;
                 onText?.(ackMessage).catch(() => { });
-                this.handleTeamTask('Clementine', 'clementine', text, targetProfile)
+                // Track this task so "Stop" can abort it along with the chat query.
+                const teamAbortController = new AbortController();
+                const sess = this.getSession(sessionKey);
+                if (!sess.teamTaskControllers)
+                    sess.teamTaskControllers = new Set();
+                sess.teamTaskControllers.add(teamAbortController);
+                this.handleTeamTask('Clementine', 'clementine', text, targetProfile, undefined, teamAbortController)
                     .then(response => {
                     if (!response)
                         return;
                     const delivery = `**${targetProfile.name}**: ${response}`;
-                    return this._dispatcher?.send(delivery, { sessionKey });
+                    return this._dispatcher?.send(delivery, { sessionKey, agentSlug: targetProfile.slug });
                 })
                     .catch(err => {
+                    if (teamAbortController.signal.aborted) {
+                        logger.info({ target: decision.targetAgent, sessionKey }, 'Delegated task aborted by user');
+                        return;
+                    }
                     logger.warn({ err, target: decision.targetAgent }, 'Delegated task failed');
-                    void this._dispatcher?.send(`**${targetProfile.name}** hit an error handling that: ${String(err).slice(0, 200)}`, { sessionKey });
+                    void this._dispatcher?.send(`**${targetProfile.name}** hit an error handling that: ${String(err).slice(0, 200)}`, { sessionKey, agentSlug: targetProfile.slug });
+                })
+                    .finally(() => {
+                    const s = this.sessions.get(sessionKey);
+                    s?.teamTaskControllers?.delete(teamAbortController);
                 });
                 return { delegated: true, ackMessage };
             }
@@ -580,17 +614,28 @@ export class Gateway {
         return this.sessions.get(sessionKey)?.lock !== undefined;
     }
     /**
-     * Abort an in-progress chat query for a session.
-     * Returns true if there was an active query to abort.
+     * Abort an in-progress chat query AND any in-flight delegated team tasks
+     * for this session. Returns true if anything was actually aborted.
      */
     stopSession(sessionKey) {
-        const ac = this.sessions.get(sessionKey)?.abortController;
+        const s = this.sessions.get(sessionKey);
+        let aborted = false;
+        const ac = s?.abortController;
         if (ac && !ac.signal.aborted) {
             ac.abort();
-            logger.info({ sessionKey }, 'Session stopped by user');
-            return true;
+            aborted = true;
         }
-        return false;
+        if (s?.teamTaskControllers?.size) {
+            for (const tac of s.teamTaskControllers) {
+                if (!tac.signal.aborted)
+                    tac.abort();
+            }
+            aborted = true;
+            logger.info({ sessionKey, count: s.teamTaskControllers.size }, 'Aborted in-flight team tasks');
+        }
+        if (aborted)
+            logger.info({ sessionKey }, 'Session stopped by user');
+        return aborted;
     }
     /**
      * Serialize access to a session. If a query is already in-flight when a new
@@ -964,21 +1009,47 @@ export class Gateway {
                         }
                     }
                     // ── Deep mode detection ─────────────────────────────────────
-                    // Agent proposes background execution for complex tasks
-                    const deepMatch = response?.match(/^\[DEEP_MODE:\s*(.+?)\]\s*/s);
+                    // Agent proposes background execution for complex tasks.
+                    //
+                    // Syntax:
+                    //   [DEEP_MODE: task description]
+                    //   [DEEP_MODE(work_dir=/abs/path): task description]   ← NEW
+                    //
+                    // The optional work_dir= parameter runs the unleashed task in a
+                    // different project directory. Useful when the task belongs to
+                    // a Claude Code project with its own CLAUDE.md / slash commands
+                    // (e.g. the proposal-builder project for audit-queue approvals).
+                    const deepMatch = response?.match(/^\[DEEP_MODE(?:\(([^)]+)\))?:\s*(.+?)\]\s*/s);
                     if (deepMatch) {
-                        const taskDesc = deepMatch[1].trim() || text;
-                        const ack = response.replace(/^\[DEEP_MODE:[^\]]*\]\s*/s, '').trim();
+                        const paramsStr = deepMatch[1] ?? '';
+                        const taskDesc = deepMatch[2].trim() || text;
+                        const ack = response.replace(/^\[DEEP_MODE(?:\([^)]*\))?:[^\]]*\]\s*/s, '').trim();
                         logger.info({ sessionKey, task: taskDesc }, 'Deep mode triggered by agent');
+                        // Parse optional work_dir parameter — strict: must be an absolute
+                        // path and must exist. Anything else falls back to default.
+                        let deepWorkDir;
+                        const wdMatch = paramsStr.match(/work_dir=([^,\s]+)/);
+                        if (wdMatch) {
+                            const candidate = wdMatch[1].trim().replace(/^["']|["']$/g, '');
+                            if (path.isAbsolute(candidate) && existsSync(candidate)) {
+                                deepWorkDir = candidate;
+                                logger.info({ sessionKey, workDir: deepWorkDir }, 'Deep mode using custom work_dir');
+                            }
+                            else {
+                                logger.warn({ sessionKey, candidate }, 'Deep mode work_dir rejected (not absolute or does not exist)');
+                            }
+                        }
                         const currentSess = this.getSession(sessionKey);
                         const jobName = `deep-${Date.now()}`;
                         currentSess.deepTask = { jobName, taskDesc, startedAt: new Date().toISOString() };
+                        const deepAgentSlug = this._agentSlugFromSessionKey(sessionKey);
                         // Spawn unleashed task in background — don't await
                         this.assistant.runUnleashedTask(jobName, `${taskDesc}\n\nOriginal request: ${text}`, 2, // tier 2 (Bash/Write/Edit enabled)
                         undefined, // default maxTurns (75/phase)
                         undefined, // default model
-                        undefined, // default workDir
-                        1).then(async (result) => {
+                        deepWorkDir, // honors [DEEP_MODE(work_dir=...)] if provided
+                        1, // maxHours
+                        deepAgentSlug).then(async (result) => {
                             logger.info({ sessionKey, jobName, resultLen: result?.length ?? 0 }, 'Deep mode task completed');
                             if (result && result !== '__NOTHING__') {
                                 this.assistant.injectPendingContext(sessionKey, text, result);
@@ -1005,7 +1076,8 @@ export class Gateway {
                         const currentSess = this.getSession(sessionKey);
                         const jobName = `deep-${Date.now()}`;
                         currentSess.deepTask = { jobName, taskDesc: text.slice(0, 200), startedAt: new Date().toISOString() };
-                        this.assistant.runUnleashedTask(jobName, `Continue working on this task. The user asked: ${text}\n\nYou already started in a quick session and made ${toolActivityCount} tool calls. Pick up where you left off and complete the work.`, 2, undefined, undefined, undefined, 1).then(async (result) => {
+                        const escAgentSlug = this._agentSlugFromSessionKey(sessionKey);
+                        this.assistant.runUnleashedTask(jobName, `Continue working on this task. The user asked: ${text}\n\nYou already started in a quick session and made ${toolActivityCount} tool calls. Pick up where you left off and complete the work.`, 2, undefined, undefined, undefined, 1, escAgentSlug).then(async (result) => {
                             logger.info({ sessionKey, jobName, resultLen: result?.length ?? 0 }, 'Auto-escalated deep mode completed');
                             if (result && result !== '__NOTHING__') {
                                 this.assistant.injectPendingContext(sessionKey, text, result);
@@ -1059,9 +1131,10 @@ export class Gateway {
                         const currentSess = this.getSession(sessionKey);
                         const jobName = `deep-${Date.now()}`;
                         currentSess.deepTask = { jobName, taskDesc: text.slice(0, 200), startedAt: new Date().toISOString() };
+                        const mtAgentSlug = this._agentSlugFromSessionKey(sessionKey);
                         // Grab any partial response that was streamed before the error
                         const partialResponse = wrappedOnText ? lastStreamedText : '';
-                        this.assistant.runUnleashedTask(jobName, `Continue working on this task. The user asked: ${text}\n\nYou already started and ran out of turns. Pick up where you left off and complete the work.`, 2, undefined, undefined, undefined, 1).then(async (result) => {
+                        this.assistant.runUnleashedTask(jobName, `Continue working on this task. The user asked: ${text}\n\nYou already started and ran out of turns. Pick up where you left off and complete the work.`, 2, undefined, undefined, undefined, 1, mtAgentSlug).then(async (result) => {
                             logger.info({ sessionKey, jobName, resultLen: result?.length ?? 0 }, 'Max-turns deep mode completed');
                             if (result && result !== '__NOTHING__') {
                                 this.assistant.injectPendingContext(sessionKey, text, result);
@@ -1134,19 +1207,19 @@ export class Gateway {
             releaseLane();
         }
     }
-    async handleCronJob(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, mode = 'standard', maxHours, timeoutMs, successCriteria) {
+    async handleCronJob(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, mode = 'standard', maxHours, timeoutMs, successCriteria, agentSlug) {
         const releaseLane = await lanes.acquire('cron');
         try {
-            logger.info(`Running cron job: ${jobName}${workDir ? ` in ${workDir}` : ''}${mode === 'unleashed' ? ' (unleashed)' : ''}`);
+            logger.info(`Running cron job: ${jobName}${workDir ? ` in ${workDir}` : ''}${mode === 'unleashed' ? ' (unleashed)' : ''}${agentSlug && agentSlug !== 'clementine' ? ` as ${agentSlug}` : ''}`);
             events.emit('cron:start', { jobName, tier, mode, timestamp: Date.now() });
             const cronStart = Date.now();
             try {
                 let response;
                 if (mode === 'unleashed') {
-                    response = await this.assistant.runUnleashedTask(jobName, jobPrompt, tier, maxTurns, model, workDir, maxHours);
+                    response = await this.assistant.runUnleashedTask(jobName, jobPrompt, tier, maxTurns, model, workDir, maxHours, agentSlug);
                 }
                 else {
-                    response = await this.assistant.runCronJob(jobName, jobPrompt, tier, maxTurns, model, workDir, timeoutMs, successCriteria);
+                    response = await this.assistant.runCronJob(jobName, jobPrompt, tier, maxTurns, model, workDir, timeoutMs, successCriteria, agentSlug);
                 }
                 // Re-baseline integrity checksums after cron job (may write to vault)
                 scanner.refreshIntegrity();
@@ -1169,11 +1242,11 @@ export class Gateway {
      * as cron unleashed jobs, so agents can work until done instead of being
      * killed by the 5-minute interactive chat timeout.
      */
-    async handleTeamTask(fromName, fromSlug, content, profile, onText) {
+    async handleTeamTask(fromName, fromSlug, content, profile, onText, abortController) {
         const releaseLane = await lanes.acquire('cron');
         try {
             logger.info({ fromSlug, toSlug: profile.slug }, 'Running team message as autonomous task');
-            const response = await this.assistant.runTeamTask(fromName, fromSlug, content, profile, onText);
+            const response = await this.assistant.runTeamTask(fromName, fromSlug, content, profile, onText, abortController);
             scanner.refreshIntegrity();
             return response;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",