clementine-agent 1.0.13 → 1.0.15

package/dist/agent/assistant.js

@@ -982,6 +982,13 @@ Never spawn a sub-agent with vague instructions like "handle this brief" — tel
                 const matchedSkills = searchSkillsSync(this._lastUserMessage, 1, profile?.slug);
                 if (matchedSkills.length > 0 && matchedSkills[0].score >= 4) {
                     const skill = matchedSkills[0];
+                    this.memoryStore?.logSkillUse?.({
+                        skillName: skill.name,
+                        sessionKey: sessionKey ?? null,
+                        queryText: this._lastUserMessage,
+                        score: skill.score,
+                        agentSlug: profile?.slug ?? null,
+                    });
                     let skillBlock = `## Relevant Skill: ${skill.title}\n\n${skill.content.slice(0, 800)}`;
                     // Surface linked tools + warn about whitelist conflicts
                     if (skill.toolsUsed.length > 0) {
@@ -1419,6 +1426,13 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             return `## Relevant Procedures (from past successful executions)\n\n` +
                                 matchedSkills.map(s => {
                                     recordSkillUse(s.name);
+                                    this.memoryStore?.logSkillUse?.({
+                                        skillName: s.name,
+                                        sessionKey: sessionKey ?? null,
+                                        queryText: enrichedQuery,
+                                        score: s.score,
+                                        agentSlug: agentSlug || null,
+                                    });
                                     return `## Skill: ${s.title}\n${s.content}`;
                                 }).join('\n\n');
                         }
@@ -3125,10 +3139,18 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         try {
             const { searchSkills, recordSkillUse } = await import('./skill-extractor.js');
             const cronAgentSlug = sdkOptions.env?.CLEMENTINE_TEAM_AGENT;
-            const matchedSkills = searchSkills(jobName + ' ' + jobPrompt.slice(0, 200), 2, cronAgentSlug || undefined);
+            const skillQuery = jobName + ' ' + jobPrompt.slice(0, 200);
+            const matchedSkills = searchSkills(skillQuery, 2, cronAgentSlug || undefined);
             if (matchedSkills.length > 0) {
                 const skillLines = matchedSkills.map(s => {
                     recordSkillUse(s.name);
+                    this.memoryStore?.logSkillUse?.({
+                        skillName: s.name,
+                        sessionKey: `cron:${cronAgentSlug ?? 'clementine'}:${jobName}`,
+                        queryText: skillQuery,
+                        score: s.score,
+                        agentSlug: cronAgentSlug || null,
+                    });
                     let block = `### ${s.title}\n${s.content}`;
                     if (s.toolsUsed.length > 0)
                         block += `\n**Tools:** ${s.toolsUsed.join(', ')}`;
@@ -3475,11 +3497,19 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 try {
                     const { searchSkills, recordSkillUse } = await import('./skill-extractor.js');
                     const unleashedAgentSlug = jobName.includes(':') ? jobName.split(':')[0] : undefined;
-                    const matchedSkills = searchSkills(jobName + ' ' + jobPrompt.slice(0, 200), 2, unleashedAgentSlug);
+                    const unleashedSkillQuery = jobName + ' ' + jobPrompt.slice(0, 200);
+                    const matchedSkills = searchSkills(unleashedSkillQuery, 2, unleashedAgentSlug);
                     if (matchedSkills.length > 0) {
                         unleashedSkillContext = `\n\n## Learned Procedures\nFollow these proven approaches when applicable:\n\n` +
                             matchedSkills.map(s => {
                                 recordSkillUse(s.name);
+                                this.memoryStore?.logSkillUse?.({
+                                    skillName: s.name,
+                                    sessionKey: `unleashed:${jobName}`,
+                                    queryText: unleashedSkillQuery,
+                                    score: s.score,
+                                    agentSlug: unleashedAgentSlug || null,
+                                });
                                 let block = `### ${s.title}\n${s.content}`;
                                 if (s.toolsUsed.length > 0)
                                     block += `\n**Tools:** ${s.toolsUsed.join(', ')}`;

package/dist/agent/self-improve.js

@@ -168,6 +168,29 @@ export class SelfImproveLoop {
             logger.info('Captured SOUL.md baseline for drift detection');
         }
         const state = this.loadState();
+        // If a prior run aborted on an infrastructure error that can't be fixed
+        // by retrying (malformed MCP tool schema, bad auth, etc.), don't spin
+        // the loop pointlessly. Wait at least 24h before re-probing — this gives
+        // the owner time to fix the infra and prevents us from writing dozens
+        // of identical error experiments. The failure monitor surfaces the
+        // infraError to the owner via the broken-jobs pipeline.
+        if (state.infraError && state.lastRunAt) {
+            const hoursSinceRun = (Date.now() - Date.parse(state.lastRunAt)) / 3_600_000;
+            if (Number.isFinite(hoursSinceRun) && hoursSinceRun < 24) {
+                logger.warn({
+                    category: state.infraError.category,
+                    diagnostic: state.infraError.diagnostic,
+                    hoursSinceRun: Math.round(hoursSinceRun),
+                }, 'Self-improve skipped — prior infra error still in cooldown. See Broken Jobs panel.');
+                state.status = 'completed';
+                this.saveState(state);
+                return state;
+            }
+            // Past cooldown — clear the flag and probe fresh. If it still errors,
+            // the loop will set it again.
+            logger.info('Self-improve: infra error cooldown elapsed, probing again');
+            delete state.infraError;
+        }
         state.status = 'running';
         state.lastRunAt = new Date().toISOString();
         state.currentIteration = 0;

package/dist/agent/skill-extractor.d.ts

@@ -69,4 +69,14 @@ export declare function listSkills(agentSlug?: string): Array<{
     updatedAt: string;
     agentSlug?: string;
 }>;
+/**
+ * Move skills that were never used (useCount=0, no usage telemetry rows) and
+ * are older than `olderThanDays` to the `.archive/` subdirectory inside their
+ * skill dir. Returns the list of archived skill names.
+ *
+ * `retrievalCount(name)` is consulted so that even skills whose frontmatter
+ * useCount wasn't bumped (the FS write is best-effort) still get preserved
+ * when the SQLite telemetry shows retrievals.
+ */
+export declare function archiveStaleSkills(olderThanDays?: number, retrievalCount?: (skillName: string) => number): string[];
 //# sourceMappingURL=skill-extractor.d.ts.map

package/dist/agent/skill-extractor.js

@@ -424,6 +424,67 @@ export function listSkills(agentSlug) {
     }
     return results;
 }
+// ── Stale skill archival ────────────────────────────────────────────
+/**
+ * Move skills that were never used (useCount=0, no usage telemetry rows) and
+ * are older than `olderThanDays` to the `.archive/` subdirectory inside their
+ * skill dir. Returns the list of archived skill names.
+ *
+ * `retrievalCount(name)` is consulted so that even skills whose frontmatter
+ * useCount wasn't bumped (the FS write is best-effort) still get preserved
+ * when the SQLite telemetry shows retrievals.
+ */
+export function archiveStaleSkills(olderThanDays = 90, retrievalCount) {
+    ensureDirs();
+    const archived = [];
+    const cutoffMs = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+    const dirs = [];
+    if (existsSync(GLOBAL_SKILLS_DIR))
+        dirs.push(GLOBAL_SKILLS_DIR);
+    if (existsSync(AGENTS_DIR)) {
+        for (const entry of readdirSync(AGENTS_DIR)) {
+            const candidate = path.join(AGENTS_DIR, entry, 'skills');
+            if (existsSync(candidate))
+                dirs.push(candidate);
+        }
+    }
+    for (const dir of dirs) {
+        const archiveDir = path.join(dir, '.archive');
+        for (const file of readdirSync(dir).filter(f => f.endsWith('.md'))) {
+            const filePath = path.join(dir, file);
+            try {
+                const parsed = matter(readFileSync(filePath, 'utf-8'));
+                const name = file.replace(/\.md$/, '');
+                const useCount = Number(parsed.data.useCount ?? 0);
+                const createdAt = parsed.data.createdAt ? Date.parse(parsed.data.createdAt) : NaN;
+                if (!Number.isFinite(createdAt) || createdAt > cutoffMs)
+                    continue;
+                if (useCount > 0)
+                    continue;
+                if (retrievalCount && retrievalCount(name) > 0)
+                    continue;
+                if (!existsSync(archiveDir))
+                    mkdirSync(archiveDir, { recursive: true });
+                const archivePath = path.join(archiveDir, file);
+                copyFileSync(filePath, archivePath);
+                unlinkSync(filePath);
+                // Also move the backup if it exists
+                const bakPath = filePath.replace(/\.md$/, '.md.bak');
+                if (existsSync(bakPath)) {
+                    try {
+                        copyFileSync(bakPath, archivePath.replace(/\.md$/, '.md.bak'));
+                        unlinkSync(bakPath);
+                    }
+                    catch { /* best-effort */ }
+                }
+                archived.push(name);
+                logger.info({ name, dir }, 'Archived stale skill (unused for ' + olderThanDays + '+ days)');
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    return archived;
+}
 // ── Helpers ─────────────────────────────────────────────────────────
 function slugify(text) {
     return text

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

@@ -72,6 +72,10 @@ export declare class AgentBotClient {
      * Used by BotManager.sendAsAgent() for cron result routing.
      */
     sendNotification(text: string, embed?: EmbedBuilder): Promise<void>;
+    /** Send a DM to a specific user via this agent bot. */
+    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;

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

@@ -254,6 +254,41 @@ export class AgentBotClient {
             }
         }
     }
+    /** Send a DM to a specific user via this agent bot. */
+    async sendDmTo(userId, text, embed) {
+        if (this.status !== 'online')
+            throw new Error(`Bot ${this.config.slug} is not online`);
+        const user = await this.client.users.fetch(userId, { force: true });
+        const dmChannel = await user.createDM();
+        if (embed) {
+            await dmChannel.send({ embeds: [embed] });
+        }
+        else {
+            const { chunkText } = await import('./discord-utils.js');
+            for (const chunk of chunkText(text, 1900)) {
+                await dmChannel.send(chunk);
+            }
+        }
+    }
+    /** Send a message to a specific channel via this agent bot. */
+    async sendToChannel(channelId, text, embed) {
+        if (this.status !== 'online')
+            throw new Error(`Bot ${this.config.slug} is not online`);
+        const channel = this.client.channels.cache.get(channelId)
+            ?? await this.client.channels.fetch(channelId).catch(() => null);
+        if (!channel || !('send' in channel)) {
+            throw new Error(`Channel ${channelId} not available to bot ${this.config.slug}`);
+        }
+        if (embed) {
+            await channel.send({ embeds: [embed] });
+        }
+        else {
+            const { chunkText } = await import('./discord-utils.js');
+            for (const chunk of chunkText(text, 1900)) {
+                await channel.send(chunk);
+            }
+        }
+    }
     /** Send a startup status embed to the owner's DMs. */
     async sendStartupStatus() {
         if (!this.config.ownerId)

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

@@ -63,6 +63,10 @@ export declare class BotManager {
      * Throws if the bot is unavailable — callers should fall back to main bot.
      */
     sendAsAgent(slug: string, text: string): Promise<void>;
+    /** Send a DM to a specific user through the agent's bot. */
+    sendAsAgentToUser(slug: string, userId: string, text: string): Promise<void>;
+    /** Send a message to a specific channel through the agent's bot. */
+    sendAsAgentToChannel(slug: string, channelId: string, text: string): Promise<void>;
     /**
      * Deliver a team message to an agent's bot — posts the message visibly
      * in the bot's channel and triggers the agent to process and respond.

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

@@ -176,6 +176,22 @@ export class BotManager {
         const embed = formatCronEmbed(text);
         await bot.sendNotification(text, embed ?? undefined);
     }
+    /** Send a DM to a specific user through the agent's bot. */
+    async sendAsAgentToUser(slug, userId, text) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            throw new Error(`No bot for agent '${slug}'`);
+        const embed = formatCronEmbed(text);
+        await bot.sendDmTo(userId, text, embed ?? undefined);
+    }
+    /** Send a message to a specific channel through the agent's bot. */
+    async sendAsAgentToChannel(slug, channelId, text) {
+        const bot = this.bots.get(slug);
+        if (!bot)
+            throw new Error(`No bot for agent '${slug}'`);
+        const embed = formatCronEmbed(text);
+        await bot.sendToChannel(channelId, text, embed ?? undefined);
+    }
     /**
      * Deliver a team message to an agent's bot — posts the message visibly
      * in the bot's channel and triggers the agent to process and respond.

package/dist/channels/discord.js

@@ -1671,7 +1671,148 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
     // Cache the owner's DM channel from successful interactions so
     // cron/heartbeat notifications don't depend on a fresh API fetch.
     let cachedDmChannel = null;
+    /**
+     * Send `text` to a specific channel via the main bot. Returns true on success.
+     * Caller should fall back to default delivery on failure.
+     */
+    async function sendToMainBotChannel(channelId, text) {
+        try {
+            const channel = client.channels.cache.get(channelId)
+                ?? await client.channels.fetch(channelId).catch(() => null);
+            if (!channel || !('send' in channel))
+                return false;
+            const embed = formatCronEmbed(text);
+            if (embed) {
+                await channel.send({ embeds: [embed] });
+            }
+            else {
+                for (const chunk of chunkText(text, 1900)) {
+                    await channel.send(chunk);
+                }
+            }
+            return true;
+        }
+        catch (err) {
+            logger.warn({ err, channelId }, 'Main bot channel send failed');
+            return false;
+        }
+    }
+    /** Send a DM to a specific user via the main bot. Returns true on success. */
+    async function sendMainBotDm(userId, text) {
+        try {
+            const user = await client.users.fetch(userId, { force: true });
+            const dmChannel = await user.createDM();
+            const embed = formatCronEmbed(text);
+            if (embed) {
+                await dmChannel.send({ embeds: [embed] });
+            }
+            else {
+                for (const chunk of chunkText(text, 1900)) {
+                    await dmChannel.send(chunk);
+                }
+            }
+            return true;
+        }
+        catch (err) {
+            logger.warn({ err, userId }, 'Main bot DM send failed');
+            return false;
+        }
+    }
+    /**
+     * Route a notification back to the channel/user identified by sessionKey.
+     * Returns true when delivered; false if the caller should fall back to default routing.
+     *
+     * Session key formats:
+     *   discord:user:{userId}                              → main bot DM to user
+     *   discord:channel:{channelId}:{userId}               → main bot, send in channel
+     *   discord:channel:{channelId}:{slug}:{userId}        → agent bot for {slug}, send in channel
+     *   discord:agent:{slug}:{userId}                      → agent bot DM to user
+     *   discord:member:{channelId}:{userId}                → agent bot that owns {channelId}, send in channel
+     *   discord:member:{channelId}:{slug}:{userId}         → agent bot for {slug}, send in channel
+     *   discord:member-dm:{slug}:{userId}                  → agent bot DM to non-owner user
+     */
+    async function trySessionRouting(sessionKey, text) {
+        const parts = sessionKey.split(':');
+        if (parts[0] !== 'discord' || parts.length < 3)
+            return false;
+        const kind = parts[1];
+        try {
+            if (kind === 'user' && parts[2]) {
+                return await sendMainBotDm(parts[2], text);
+            }
+            if (kind === 'channel' && parts[2]) {
+                const channelId = parts[2];
+                // discord:channel:{channelId}:{slug}:{userId} → agent bot
+                if (parts.length >= 5 && botManager?.hasBot(parts[3])) {
+                    try {
+                        await botManager.sendAsAgentToChannel(parts[3], channelId, text);
+                        return true;
+                    }
+                    catch (err) {
+                        logger.warn({ err, slug: parts[3], channelId }, 'Agent bot channel send failed — trying main bot');
+                    }
+                }
+                return await sendToMainBotChannel(channelId, text);
+            }
+            if (kind === 'agent' && parts[2] && parts[3]) {
+                const slug = parts[2];
+                const userId = parts[3];
+                if (botManager?.hasBot(slug)) {
+                    try {
+                        await botManager.sendAsAgentToUser(slug, userId, text);
+                        return true;
+                    }
+                    catch (err) {
+                        logger.warn({ err, slug, userId }, 'Agent bot DM send failed');
+                        return false;
+                    }
+                }
+                return false;
+            }
+            if (kind === 'member' && parts[2]) {
+                const channelId = parts[2];
+                // Figure out which agent owns this channel
+                const slug = parts.length >= 5 ? parts[3] : botManager?.getAgentForChannel(channelId) ?? null;
+                if (slug && botManager?.hasBot(slug)) {
+                    try {
+                        await botManager.sendAsAgentToChannel(slug, channelId, text);
+                        return true;
+                    }
+                    catch (err) {
+                        logger.warn({ err, slug, channelId }, 'Agent bot channel send failed for member session');
+                    }
+                }
+                return await sendToMainBotChannel(channelId, text);
+            }
+            if (kind === 'member-dm' && parts[2] && parts[3]) {
+                const slug = parts[2];
+                const userId = parts[3];
+                if (botManager?.hasBot(slug)) {
+                    try {
+                        await botManager.sendAsAgentToUser(slug, userId, text);
+                        return true;
+                    }
+                    catch (err) {
+                        logger.warn({ err, slug, userId }, 'Agent bot DM send failed for member-dm session');
+                        return false;
+                    }
+                }
+                return false;
+            }
+        }
+        catch (err) {
+            logger.warn({ err, sessionKey }, 'Session routing failed');
+        }
+        return false;
+    }
     async function discordNotify(text, context) {
+        // Session-aware routing: send back to the originating channel/user when we know it.
+        if (context?.sessionKey) {
+            const routed = await trySessionRouting(context.sessionKey, text);
+            if (routed)
+                return;
+            // Fall through to legacy routing if session routing couldn't deliver
+        }
         // Route to agent bot if available
         if (context?.agentSlug && botManager?.hasBot(context.agentSlug)) {
             try {

package/dist/channels/slack.js

@@ -175,7 +175,14 @@ export async function startSlack(gateway, dispatcher, slackBotManager) {
         }
     });
     // Register notification sender
-    async function slackNotify(text) {
+    async function slackNotify(text, context) {
+        // Session-aware routing: post back to the originating channel if known.
+        if (context?.sessionKey) {
+            const routed = await trySlackSessionRouting(context.sessionKey, text);
+            if (routed)
+                return;
+            // Fall back to owner DM below
+        }
         if (!SLACK_OWNER_USER_ID)
             return;
         try {
@@ -189,6 +196,49 @@ export async function startSlack(gateway, dispatcher, slackBotManager) {
             logger.error({ err }, 'Failed to send Slack notification');
         }
     }
+    /**
+     * Route a notification back to the Slack channel/thread identified by sessionKey.
+     * Returns true on success.
+     *
+     * Session key formats:
+     *   slack:user:{userId}                          → DM to user
+     *   slack:channel:{channelId}:{userId}           → post in channel
+     *   slack:channel:{channelId}:{slug}:{userId}    → post in channel (agent-scoped chat)
+     *   slack:dm:{userId}                            → DM to user
+     *   slack:agent:{slug}:{userId}                  → DM to user (agent-scoped)
+     */
+    async function trySlackSessionRouting(sessionKey, text) {
+        const parts = sessionKey.split(':');
+        if (parts[0] !== 'slack' || parts.length < 3)
+            return false;
+        const kind = parts[1];
+        try {
+            if ((kind === 'user' || kind === 'dm') && parts[2]) {
+                const dm = await app.client.conversations.open({ users: parts[2] });
+                const channelId = dm.channel?.id;
+                if (!channelId)
+                    return false;
+                await sendChunkedSlack(app.client, channelId, mdToSlack(text));
+                return true;
+            }
+            if (kind === 'channel' && parts[2]) {
+                await sendChunkedSlack(app.client, parts[2], mdToSlack(text));
+                return true;
+            }
+            if (kind === 'agent' && parts[3]) {
+                const dm = await app.client.conversations.open({ users: parts[3] });
+                const channelId = dm.channel?.id;
+                if (!channelId)
+                    return false;
+                await sendChunkedSlack(app.client, channelId, mdToSlack(text));
+                return true;
+            }
+        }
+        catch (err) {
+            logger.warn({ err, sessionKey }, 'Slack session routing failed');
+        }
+        return false;
+    }
     dispatcher.register('slack', slackNotify);
     logger.info('Starting Slack bot (Socket Mode)...');
     await app.start();

package/dist/channels/telegram.js

@@ -214,7 +214,20 @@ export async function startTelegram(gateway, dispatcher) {
         await ctx.reply('Voice messages are not yet supported in this version.');
     });
     // Register notification sender
-    async function telegramNotify(text) {
+    async function telegramNotify(text, context) {
+        // Session-aware routing: send back to the originating chat when known.
+        if (context?.sessionKey) {
+            const chatId = parseTelegramSessionKey(context.sessionKey);
+            if (chatId) {
+                try {
+                    await sendChunked(bot, chatId, mdToTelegram(text));
+                    return;
+                }
+                catch (err) {
+                    logger.warn({ err, sessionKey: context.sessionKey }, 'Telegram session routing failed — falling back to owner');
+                }
+            }
+        }
         if (!TELEGRAM_OWNER_ID || ownerIdNum === 0)
             return;
         try {
@@ -225,6 +238,20 @@ export async function startTelegram(gateway, dispatcher) {
             logger.error({ err }, 'Failed to send Telegram notification');
         }
     }
+    /**
+     * Parse a Telegram sessionKey and return the chat ID to post in.
+     * Formats supported: telegram:user:{chatId}, telegram:{chatId}.
+     */
+    function parseTelegramSessionKey(sessionKey) {
+        const parts = sessionKey.split(':');
+        if (parts[0] !== 'telegram')
+            return null;
+        const raw = parts[1] === 'user' ? parts[2] : parts[1];
+        if (!raw)
+            return null;
+        const n = Number(raw);
+        return Number.isFinite(n) && n !== 0 ? n : null;
+    }
     dispatcher.register('telegram', telegramNotify);
     logger.info('Starting Telegram bot (long polling)...');
     await bot.start({