clementine-agent 1.0.13 → 1.0.14

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/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({

package/dist/cli/dashboard.js

@@ -135,8 +135,18 @@ async function cachedAsync(key, ttlMs, compute) {
 // ── Lazy gateway for chat ────────────────────────────────────────────
 let gatewayInstance = null;
 let gatewayInitializing = false;
+let gatewayDispatcher = null;
+/** SSE broadcaster; set once cmdDashboard has built the SSE infrastructure. */
+let dashboardSseBroadcast = null;
 /** Reset the cached gateway (called when daemon PID changes). */
 function resetGateway() {
+    if (gatewayDispatcher) {
+        try {
+            gatewayDispatcher.shutdown();
+        }
+        catch { /* best-effort */ }
+        gatewayDispatcher = null;
+    }
     gatewayInstance = null;
     responseCache.clear();
 }
@@ -156,6 +166,26 @@ async function getGateway() {
         gatewayInstance = new GatewayClass(assistant);
         const { setApprovalCallback } = await import('../agent/hooks.js');
         setApprovalCallback(async () => false);
+        // Wire a local NotificationDispatcher so deep-task results launched from
+        // dashboard chat sessions can be pushed back into the browser via SSE.
+        try {
+            const { NotificationDispatcher } = await import('../gateway/notifications.js');
+            const dispatcher = new NotificationDispatcher();
+            dispatcher.register('dashboard', async (text, context) => {
+                if (!dashboardSseBroadcast)
+                    return;
+                dashboardSseBroadcast({
+                    type: 'deep_result',
+                    data: { sessionKey: context?.sessionKey ?? null, text },
+                });
+            });
+            gatewayInstance.setDispatcher(dispatcher);
+            gatewayDispatcher = dispatcher;
+        }
+        catch (err) {
+            // Non-fatal — deep-task results from dashboard sessions just won't surface live
+            console.warn('Failed to wire dashboard SSE dispatcher:', err);
+        }
         return gatewayInstance;
     }
     catch (err) {
@@ -2009,6 +2039,8 @@ export async function cmdDashboard(opts) {
             }
         }
     }
+    // Let the lazy-gateway dispatcher publish deep_result events through SSE.
+    dashboardSseBroadcast = broadcastEvent;
     // SSE events handler moved before auth middleware (see above)
     // ── POST routes (actions) ──────────────────────────────────────
     app.post('/api/cron/run/:job', (req, res) => {
@@ -3743,19 +3775,87 @@ export async function cmdDashboard(opts) {
         }
     });
     // ── Skills (Procedural Memory) API ──────────────────────────────────
-    app.get('/api/skills', (_req, res) => {
+    // NOTE: /api/skills/pending routes must come before /api/skills/:name so
+    // Express doesn't capture "pending" as a :name param.
+    app.get('/api/skills/pending', async (_req, res) => {
+        try {
+            const { listPendingSkills } = await import('../agent/skill-extractor.js');
+            res.json({ skills: listPendingSkills() });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/skills/pending/:name/approve', async (req, res) => {
+        try {
+            const { approvePendingSkill } = await import('../agent/skill-extractor.js');
+            const result = approvePendingSkill(req.params.name);
+            if (!result.ok) {
+                res.status(404).json(result);
+                return;
+            }
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/skills/pending/:name/reject', async (req, res) => {
+        try {
+            const { rejectPendingSkill } = await import('../agent/skill-extractor.js');
+            const result = rejectPendingSkill(req.params.name);
+            if (!result.ok) {
+                res.status(404).json(result);
+                return;
+            }
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.get('/api/skills', async (_req, res) => {
         try {
             const skillsDir = path.join(VAULT_DIR, '00-System', 'skills');
             if (!existsSync(skillsDir)) {
                 res.json({ skills: [] });
                 return;
             }
+            // Aggregate last-7-day retrieval stats from skill_usage table (best-effort).
+            const usageStats = new Map();
+            if (existsSync(MEMORY_DB_PATH)) {
+                try {
+                    const Database = (await import('better-sqlite3')).default;
+                    const db = new Database(MEMORY_DB_PATH, { readonly: true });
+                    try {
+                        const rows = db.prepare(`SELECT skill_name,
+                      COUNT(*) AS retrievals,
+                      MAX(retrieved_at) AS last_retrieved_at,
+                      AVG(score) AS avg_score
+               FROM skill_usage
+               WHERE retrieved_at >= datetime('now', '-7 days')
+               GROUP BY skill_name`).all();
+                        for (const r of rows) {
+                            usageStats.set(r.skill_name, {
+                                retrievals7d: r.retrievals,
+                                lastRetrievedAt: r.last_retrieved_at,
+                                avgScore: r.avg_score,
+                            });
+                        }
+                    }
+                    catch { /* skill_usage may not exist on older DBs */ }
+                    db.close();
+                }
+                catch { /* non-fatal */ }
+            }
             const files = readdirSync(skillsDir).filter(f => f.endsWith('.md'));
             const skills = files.map(f => {
                 try {
                     const parsed = matter(readFileSync(path.join(skillsDir, f), 'utf-8'));
+                    const name = f.replace('.md', '');
+                    const stats = usageStats.get(name);
                     return {
-                        name: f.replace('.md', ''),
+                        name,
                         title: parsed.data.title ?? f,
                         description: parsed.data.description ?? '',
                         source: parsed.data.source ?? 'unknown',
@@ -3766,6 +3866,9 @@ export async function cmdDashboard(opts) {
                         lastUsed: parsed.data.lastUsed ?? null,
                         createdAt: parsed.data.createdAt ?? '',
                         updatedAt: parsed.data.updatedAt ?? '',
+                        retrievals7d: stats?.retrievals7d ?? 0,
+                        lastRetrievedAt: stats?.lastRetrievedAt ?? null,
+                        avgScore: stats?.avgScore ?? null,
                     };
                 }
                 catch {
@@ -8974,7 +9077,7 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
         <button class="active" onclick="switchTab('automations','scheduled')">Scheduled Tasks</button>
         <button onclick="switchTab('automations','timers')">Timers <span class="tab-badge" id="tab-timer-count" style="display:none">0</span></button>
         <button onclick="switchTab('automations','self-improve')">Self-Improve <span class="tab-badge" id="tab-si-pending" style="display:none">0</span></button>
-        <button onclick="switchTab('automations','skills')">Skills <span class="tab-badge" id="tab-skill-count" style="display:none">0</span></button>
+        <button onclick="switchTab('automations','skills')">Skills <span class="tab-badge" id="tab-skill-count" style="display:none">0</span><span class="tab-badge" id="tab-pending-skill-count" title="pending approval" style="display:none;background:#f59e0b;color:#000">0</span></button>
         <button onclick="switchTab('automations','analytics')">Execution Analytics</button>
       </div>
       <div id="automations-tab-content">
@@ -9032,6 +9135,13 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
               </div>
             </div>
           </div>
+          <div class="card" id="pending-skills-card" style="display:none">
+            <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
+              <span>Pending Approval</span>
+              <span class="badge badge-orange" id="pending-skills-count-badge" style="font-size:10px">0 pending</span>
+            </div>
+            <div class="card-body" id="panel-pending-skills"></div>
+          </div>
           <div class="card">
             <div class="card-header" style="display:flex;align-items:center;justify-content:space-between">
               <span>Learned Skills</span>
@@ -16031,7 +16141,83 @@ async function expandSkill(name) {
   } catch(e) { toast('Failed to load skill', 'error'); }
 }
 
+async function refreshPendingSkills() {
+  try {
+    var r = await apiFetch('/api/skills/pending');
+    var d = await r.json();
+    var pending = d.skills || [];
+    var tabBadge = document.getElementById('tab-pending-skill-count');
+    if (tabBadge) {
+      tabBadge.textContent = String(pending.length);
+      tabBadge.style.display = pending.length > 0 ? '' : 'none';
+    }
+    var card = document.getElementById('pending-skills-card');
+    var countBadge = document.getElementById('pending-skills-count-badge');
+    var container = document.getElementById('panel-pending-skills');
+    if (!container) return;
+    if (pending.length === 0) {
+      if (card) card.style.display = 'none';
+      container.innerHTML = '';
+      return;
+    }
+    if (card) card.style.display = '';
+    if (countBadge) countBadge.textContent = pending.length + ' pending';
+
+    var html = '<div style="display:flex;flex-direction:column;gap:10px">';
+    for (var s of pending) {
+      var sourceTag = s.source === 'cron' ? '<span class="badge badge-green" style="font-size:10px">cron</span>'
+        : s.source === 'unleashed' ? '<span class="badge badge-purple" style="font-size:10px">unleashed</span>'
+        : s.source === 'chat' ? '<span class="badge badge-blue" style="font-size:10px">chat</span>'
+        : '<span class="badge badge-gray" style="font-size:10px">' + esc(s.source || 'unknown') + '</span>';
+      var age = s.createdAt ? timeAgo(s.createdAt) : '';
+      var scopeTag = s.agentSlug
+        ? '<span style="font-size:10px;color:var(--text-muted)">for ' + esc(s.agentSlug) + '</span>'
+        : '<span style="font-size:10px;color:var(--text-muted)">global</span>';
+      html += '<div style="padding:12px;border:1px solid var(--border);border-radius:8px;background:var(--bg-secondary)">'
+        + '<div style="display:flex;align-items:center;gap:8px;margin-bottom:6px;flex-wrap:wrap">'
+        + '<strong>' + esc(s.title) + '</strong> ' + sourceTag + ' ' + scopeTag
+        + (age ? ' <span style="font-size:10px;color:var(--text-muted)">\\u00b7 learned ' + age + '</span>' : '')
+        + '<span style="margin-left:auto;display:flex;gap:6px">'
+        + '<button onclick="approvePendingSkill(\\x27' + esc(s.name) + '\\x27)" style="background:var(--accent);border:1px solid var(--accent);border-radius:4px;padding:3px 10px;font-size:11px;color:white;cursor:pointer">Approve</button>'
+        + '<button onclick="rejectPendingSkill(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:3px 10px;font-size:11px;color:var(--red);cursor:pointer">Reject</button>'
+        + '</span>'
+        + '</div>'
+        + '<div style="font-size:12px;color:var(--text-secondary)">' + esc(s.description || '') + '</div>'
+        + '</div>';
+    }
+    html += '</div>';
+    container.innerHTML = html;
+  } catch(e) { /* non-fatal */ }
+}
+
+async function approvePendingSkill(name) {
+  try {
+    var r = await apiJson('POST', '/api/skills/pending/' + encodeURIComponent(name) + '/approve', {});
+    if (r && r.ok) {
+      toast(r.message || 'Skill approved', 'success');
+      refreshPendingSkills();
+      refreshSkills();
+    } else {
+      toast((r && r.message) || 'Failed to approve', 'error');
+    }
+  } catch(e) { toast('Failed to approve skill', 'error'); }
+}
+
+async function rejectPendingSkill(name) {
+  if (!confirm('Reject this pending skill? It will be deleted.')) return;
+  try {
+    var r = await apiJson('POST', '/api/skills/pending/' + encodeURIComponent(name) + '/reject', {});
+    if (r && r.ok) {
+      toast(r.message || 'Skill rejected', 'success');
+      refreshPendingSkills();
+    } else {
+      toast((r && r.message) || 'Failed to reject', 'error');
+    }
+  } catch(e) { toast('Failed to reject skill', 'error'); }
+}
+
 async function refreshSkills() {
+  refreshPendingSkills();
   try {
     var r = await apiFetch('/api/skills');
     var d = await r.json();
@@ -16075,12 +16261,15 @@ async function refreshSkills() {
           + (s.toolsUsed.length > 4 ? ' <span style="font-size:10px;color:var(--text-muted)">+' + (s.toolsUsed.length - 4) + '</span>' : '')
           + '</div>';
       }
+      var retrieval7d = (typeof s.retrievals7d === 'number' && s.retrievals7d > 0)
+        ? ' \\u00b7 ' + s.retrievals7d + ' retrievals (7d)'
+        : '';
       html += '<div id="skill-card-' + esc(s.name) + '" style="padding:12px;border:1px solid var(--border);border-radius:8px;background:var(--bg-secondary)">'
         + '<div style="display:flex;align-items:center;gap:8px;margin-bottom:6px">'
         + '<strong style="cursor:pointer" onclick="expandSkill(\\x27' + esc(s.name) + '\\x27)">' + esc(s.title) + '</strong> ' + sourceTag
         + (sourceCtx ? ' ' + sourceCtx : '')
         + '<span style="margin-left:auto;display:flex;align-items:center;gap:8px">'
-        + '<span style="font-size:11px;color:var(--text-muted)">used ' + s.useCount + 'x' + (age ? ' \\u00b7 ' + age : '') + '</span>'
+        + '<span style="font-size:11px;color:var(--text-muted)">used ' + s.useCount + 'x' + (age ? ' \\u00b7 ' + age : '') + retrieval7d + '</span>'
         + '<button onclick="expandSkill(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:11px;color:var(--text-secondary);cursor:pointer">View</button>'
         + '<button onclick="editSkillInBuilder(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:11px;color:var(--accent);cursor:pointer">Edit</button>'
         + '<button onclick="deleteSkill(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:11px;color:var(--red);cursor:pointer">Delete</button>'
@@ -17538,6 +17727,34 @@ try {
         toast('Daemon restarted \u2014 refreshing data...', 'info');
         setTimeout(function() { refreshAll(); }, 1500);
       }
+      if (evt.type === 'deep_result') {
+        try {
+          var container = document.getElementById('chat-messages');
+          var text = (evt.data && evt.data.text) ? evt.data.text : '';
+          if (container && text) {
+            var emptyState = container.querySelector('.empty-state');
+            if (emptyState) emptyState.remove();
+            var row = document.createElement('div');
+            row.className = 'chat-assistant-row';
+            var av = document.createElement('div');
+            av.className = 'chat-avatar-sm';
+            av.innerHTML = (lastStatusData && lastStatusData.name ? lastStatusData.name : 'C').charAt(0).toUpperCase();
+            row.appendChild(av);
+            var bubble = document.createElement('div');
+            bubble.className = 'chat-bubble assistant';
+            bubble.innerHTML = renderMd(text);
+            var meta = document.createElement('div');
+            meta.className = 'chat-meta';
+            meta.textContent = new Date().toLocaleTimeString() + ' \u00b7 deep task';
+            bubble.appendChild(meta);
+            row.appendChild(bubble);
+            container.appendChild(row);
+            container.scrollTop = container.scrollHeight;
+          } else {
+            toast('Deep task result ready \u2014 open chat to view.', 'info');
+          }
+        } catch(e) { /* non-fatal */ }
+      }
     } catch(err) { /* ignore */ }
   };
 } catch(err) { /* SSE not supported */ }

package/dist/gateway/heartbeat-scheduler.js

@@ -174,6 +174,25 @@ export class HeartbeatScheduler {
                 logger.warn({ err }, 'Per-agent self-improvement scheduling error');
             }
         }
+        // Daily stale-skill archival: run once per day at 3 AM. Skills never
+        // retrieved in 90+ days (both frontmatter useCount and skill_usage empty)
+        // get moved to .archive/ so they stop competing in trigger matching.
+        if (hour === 3 && this.lastState.lastSkillDecayDate !== todayISO()) {
+            this.lastState.lastSkillDecayDate = todayISO();
+            this.saveState();
+            import('../agent/skill-extractor.js').then(({ archiveStaleSkills }) => {
+                try {
+                    const store = this.gateway.getMemoryStore();
+                    const archived = archiveStaleSkills(90, store ? (name) => store.skillRetrievalCount(name) : undefined);
+                    if (archived.length > 0) {
+                        logger.info({ count: archived.length, names: archived.slice(0, 5) }, 'Archived stale skills');
+                    }
+                }
+                catch (err) {
+                    logger.warn({ err }, 'Stale skill archival failed');
+                }
+            }).catch(err => logger.warn({ err }, 'Stale skill archival import failed'));
+        }
         // Evening memory consolidation: once per day between 7-9 PM
         if (hour >= 19 && hour < 21 && this.lastConsolidationDate !== todayISO()) {
             this.lastConsolidationDate = todayISO();

package/dist/gateway/notifications.js

@@ -10,6 +10,20 @@ import { DeliveryQueue } from './delivery-queue.js';
 const logger = pino({ name: 'clementine.notifications' });
 /** Safety cap — prevent runaway messages, but each channel handles its own chunking/limits. */
 const MAX_MESSAGE_LENGTH = 8000;
+/** Map a sessionKey prefix to the registered channel name that owns it. */
+function channelForSessionKey(sessionKey) {
+    if (sessionKey.startsWith('discord:'))
+        return 'discord';
+    if (sessionKey.startsWith('slack:'))
+        return 'slack';
+    if (sessionKey.startsWith('telegram:'))
+        return 'telegram';
+    if (sessionKey.startsWith('whatsapp:'))
+        return 'whatsapp';
+    if (sessionKey.startsWith('dashboard:'))
+        return 'dashboard';
+    return null;
+}
 export class NotificationDispatcher {
     senders = new Map();
     _retryQueue;
@@ -52,9 +66,20 @@ export class NotificationDispatcher {
         const capped = text.length > MAX_MESSAGE_LENGTH
             ? text.slice(0, MAX_MESSAGE_LENGTH - 20) + '\n\n_(truncated)_'
             : text;
+        // If sessionKey is set, route only to the channel that owns it.
+        // Fan out to all channels only when no originating channel is known.
+        const targetChannel = context?.sessionKey ? channelForSessionKey(context.sessionKey) : null;
+        const scopedSenders = [];
+        if (targetChannel && this.senders.has(targetChannel)) {
+            scopedSenders.push([targetChannel, this.senders.get(targetChannel)]);
+        }
+        else {
+            for (const entry of this.senders)
+                scopedSenders.push(entry);
+        }
         const channelErrors = {};
         let anySuccess = false;
-        for (const [name, sender] of this.senders) {
+        for (const [name, sender] of scopedSenders) {
             try {
                 await sender(capped, context);
                 anySuccess = true;

package/dist/gateway/router.js

@@ -185,14 +185,14 @@ export class Gateway {
         try {
             const agentReply = await this.handleMessage(sessionKey, syntheticPrompt);
             if (agentReply?.trim()) {
-                await this._dispatcher?.send(agentReply);
+                await this._dispatcher?.send(agentReply, { sessionKey });
                 logger.info({ sessionKey }, '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))
+                await this._dispatcher?.send(rawFallback.slice(0, 1500), { sessionKey })
                     .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');

package/dist/memory/store.d.ts

@@ -22,6 +22,26 @@ export declare class MemoryStore {
      * Create the database and schema if needed.
      */
     initialize(): void;
+    private _stmtLogSkillUse;
+    /**
+     * Record that a skill was retrieved and injected into a query context.
+     * Outcome is left null; a follow-up could backfill from reflection scores.
+     */
+    logSkillUse(row: {
+        skillName: string;
+        sessionKey?: string | null;
+        queryText?: string | null;
+        score?: number | null;
+        agentSlug?: string | null;
+    }): void;
+    /** Aggregate skill usage stats keyed by skill_name. */
+    skillUsageStats(windowDays?: number): Map<string, {
+        retrievals: number;
+        lastRetrievedAt: string | null;
+        avgScore: number | null;
+    }>;
+    /** Number of times a skill has been retrieved (all time). */
+    skillRetrievalCount(skillName: string): number;
     /**
      * Close the database connection.
      */

package/dist/memory/store.js

@@ -405,8 +405,72 @@ export class MemoryStore {
       CREATE INDEX IF NOT EXISTS idx_sf_sync_local ON sf_sync_log(local_table, local_id);
       CREATE INDEX IF NOT EXISTS idx_sf_sync_sfid ON sf_sync_log(sf_id);
       CREATE INDEX IF NOT EXISTS idx_sf_sync_status ON sf_sync_log(sync_status);
+
+      CREATE TABLE IF NOT EXISTS skill_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        skill_name TEXT NOT NULL,
+        session_key TEXT,
+        query_text TEXT,
+        retrieved_at TEXT NOT NULL DEFAULT (datetime('now')),
+        score REAL,
+        outcome TEXT,
+        agent_slug TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_skill_usage_name ON skill_usage(skill_name, retrieved_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_skill_usage_time ON skill_usage(retrieved_at DESC);
     `);
     }
+    // ── Skill usage telemetry ─────────────────────────────────────────
+    _stmtLogSkillUse = null;
+    /**
+     * Record that a skill was retrieved and injected into a query context.
+     * Outcome is left null; a follow-up could backfill from reflection scores.
+     */
+    logSkillUse(row) {
+        try {
+            if (!this._stmtLogSkillUse) {
+                this._stmtLogSkillUse = this.conn.prepare('INSERT INTO skill_usage (skill_name, session_key, query_text, score, agent_slug) VALUES (?, ?, ?, ?, ?)');
+            }
+            this._stmtLogSkillUse.run(row.skillName, row.sessionKey ?? null, row.queryText ? row.queryText.slice(0, 200) : null, row.score ?? null, row.agentSlug ?? null);
+        }
+        catch {
+            // Best-effort — telemetry must never break retrieval.
+        }
+    }
+    /** Aggregate skill usage stats keyed by skill_name. */
+    skillUsageStats(windowDays = 7) {
+        const out = new Map();
+        try {
+            const rows = this.conn.prepare(`SELECT skill_name,
+                COUNT(*) AS retrievals,
+                MAX(retrieved_at) AS last_retrieved_at,
+                AVG(score) AS avg_score
+         FROM skill_usage
+         WHERE retrieved_at >= datetime('now', ?)
+         GROUP BY skill_name`).all(`-${Math.max(1, Math.floor(windowDays))} days`);
+            for (const r of rows) {
+                out.set(r.skill_name, {
+                    retrievals: r.retrievals,
+                    lastRetrievedAt: r.last_retrieved_at,
+                    avgScore: r.avg_score,
+                });
+            }
+        }
+        catch {
+            // Table may not exist yet on legacy DBs — caller should tolerate empty.
+        }
+        return out;
+    }
+    /** Number of times a skill has been retrieved (all time). */
+    skillRetrievalCount(skillName) {
+        try {
+            const row = this.conn.prepare('SELECT COUNT(*) AS cnt FROM skill_usage WHERE skill_name = ?').get(skillName);
+            return row?.cnt ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
     /**
      * Close the database connection.
      */

package/dist/types.d.ts

@@ -104,6 +104,8 @@ export type OnTextCallback = (text: string) => Promise<void>;
 export type OnToolActivityCallback = (toolName: string, toolInput: Record<string, unknown>) => Promise<void>;
 export interface NotificationContext {
     agentSlug?: string;
+    /** When set, the dispatcher routes the message back to the channel that owns this session. */
+    sessionKey?: string;
 }
 export type NotificationSender = (text: string, context?: NotificationContext) => Promise<void>;
 /** Policy governing autonomous outbound email sending for an agent. */
@@ -192,6 +194,7 @@ export interface HeartbeatState {
     lastSelfImproveDate?: string;
     lastConsolidationDate?: string;
     lastAgentSiRuns?: Record<string, string>;
+    lastSkillDecayDate?: string;
     /** Proactive insight engine state */
     insightState?: {
         sentToday: string[];

package/package.json

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