clementine-agent 1.0.29 → 1.0.31

package/dist/channels/slack.js

@@ -205,32 +205,42 @@ export async function startSlack(gateway, dispatcher, slackBotManager) {
      * Returns true on success.
      *
      * Session key formats:
-     *   slack:user:{userId}                          → DM to user
+     *   slack:team:{teamId}:user:{userId}            → DM to user (workspace-namespaced, current format)
+     *   slack:team:{teamId}:dm:{userId}              → DM to user (workspace-namespaced)
+     *   slack:user:{userId}                          → DM to user (legacy, pre-namespacing)
+     *   slack:dm:{userId}                            → DM to user (legacy)
      *   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];
+        // Strip the `team:{teamId}:` workspace prefix if present so downstream
+        // routing logic stays format-agnostic. The current bolt app is connected
+        // to a single workspace, so we use the existing client regardless of which
+        // teamId the session names.
+        let effectiveParts = parts;
+        if (parts[1] === 'team' && parts.length >= 4) {
+            effectiveParts = ['slack', ...parts.slice(3)];
+        }
+        const kind = effectiveParts[1];
         try {
-            if ((kind === 'user' || kind === 'dm') && parts[2]) {
-                const dm = await app.client.conversations.open({ users: parts[2] });
+            if ((kind === 'user' || kind === 'dm') && effectiveParts[2]) {
+                const dm = await app.client.conversations.open({ users: effectiveParts[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));
+            if (kind === 'channel' && effectiveParts[2]) {
+                await sendChunkedSlack(app.client, effectiveParts[2], mdToSlack(text));
                 return true;
             }
-            if (kind === 'agent' && parts[3]) {
-                const dm = await app.client.conversations.open({ users: parts[3] });
+            if (kind === 'agent' && effectiveParts[3]) {
+                const dm = await app.client.conversations.open({ users: effectiveParts[3] });
                 const channelId = dm.channel?.id;
                 if (!channelId)
                     return false;

package/dist/gateway/cron-scheduler.js

@@ -450,9 +450,16 @@ export class CronScheduler {
         this.watchAgentsDir();
         this.watchWorkflowDir();
         this.watchTriggers();
+        // Deep-mode jobs are owned by the router (_deliverDeepResult). The
+        // cron-scheduler callbacks below only dispatch for cron-originated runs;
+        // phase updates for deep-mode runs get routed back to the originating
+        // session instead of fanning out to every registered channel.
+        const isDeepMode = (jobName) => jobName.startsWith('deep-');
         // Wire up push notifications for unleashed task completions
         this.gateway.setUnleashedCompleteCallback((jobName, result) => {
             this.completedJobs.set(jobName, Date.now());
+            if (isDeepMode(jobName))
+                return; // router handles delivery via _deliverDeepResult
             if (result && result !== '__NOTHING__') {
                 const slug = jobName.includes(':') ? jobName.split(':')[0] : undefined;
                 // Strip system metadata for clean conversational delivery
@@ -473,7 +480,15 @@ export class CronScheduler {
             const cleanOutput = output
                 .replace(/^STATUS SUMMARY:?\s*/im, '')
                 .slice(0, 500);
-            this.dispatcher.send(`Still working on it — ${cleanOutput}`, { agentSlug: slug }).catch(err => logger.debug({ err }, 'Failed to send phase progress notification'));
+            // For deep-mode runs, target the originating session so the progress
+            // update lands in the same Discord DM / Slack thread / dashboard window.
+            const deepSessionKey = isDeepMode(jobName) ? this.gateway.findDeepTaskSessionKey(jobName) : null;
+            const ctx = {};
+            if (slug)
+                ctx.agentSlug = slug;
+            if (deepSessionKey)
+                ctx.sessionKey = deepSessionKey;
+            this.dispatcher.send(`Still working on it — ${cleanOutput}`, ctx).catch(err => logger.debug({ err }, 'Failed to send phase progress notification'));
         });
         // Wire up real-time progress summaries (throttled to max 1 per 5 minutes)
         const lastProgressSent = new Map();
@@ -484,7 +499,13 @@ export class CronScheduler {
                 return; // throttle: 1 per 5 minutes
             lastProgressSent.set(jobName, now);
             const slug = jobName.includes(':') ? jobName.split(':')[0] : undefined;
-            this.dispatcher.send(summary.slice(0, 300), { agentSlug: slug }).catch(err => logger.debug({ err }, 'Failed to send phase progress summary'));
+            const deepSessionKey = isDeepMode(jobName) ? this.gateway.findDeepTaskSessionKey(jobName) : null;
+            const ctx = {};
+            if (slug)
+                ctx.agentSlug = slug;
+            if (deepSessionKey)
+                ctx.sessionKey = deepSessionKey;
+            this.dispatcher.send(summary.slice(0, 300), ctx).catch(err => logger.debug({ err }, 'Failed to send phase progress summary'));
         });
         logger.info(`Cron scheduler started with ${this.jobs.length} jobs`);
     }

package/dist/gateway/failure-monitor.d.ts

@@ -65,4 +65,22 @@ export declare function computeBrokenJobs(now?: number): BrokenJob[];
  * Returns the jobs that triggered a fresh notification (mostly for tests/logs).
  */
 export declare function runFailureSweep(send: (text: string) => Promise<unknown>, gateway?: import('./router.js').Gateway, now?: number): Promise<BrokenJob[]>;
+export interface StaleCronJob {
+    jobName: string;
+    agentSlug?: string;
+    schedule: string;
+    /** ISO timestamp of the job's most recent run, or null if it has never run. */
+    lastRunAt: string | null;
+    /** Expected time between consecutive scheduled runs, in ms. */
+    expectedIntervalMs: number;
+    /** How far past the *second* expected tick we are, in minutes. */
+    overdueMinutes: number;
+}
+/**
+ * Walk enabled cron jobs and find ones that haven't run in at least
+ * SLA_MISSED_TICKS × their expected interval. Distinct from the broken-job
+ * detector which needs actual error entries — this catches the opposite
+ * failure mode: a job that silently stopped firing at all.
+ */
+export declare function computeStaleCronJobs(now?: number): Promise<StaleCronJob[]>;
 //# sourceMappingURL=failure-monitor.d.ts.map

package/dist/gateway/failure-monitor.js

@@ -20,6 +20,7 @@ import path from 'node:path';
 import Database from 'better-sqlite3';
 import pino from 'pino';
 import { BASE_DIR, MEMORY_DB_PATH } from '../config.js';
+import { logAuditJsonl } from '../agent/hooks.js';
 const logger = pino({ name: 'clementine.failure-monitor' });
 const RUNS_DIR = path.join(BASE_DIR, 'cron', 'runs');
 const ADVISOR_EVENTS_FILE = path.join(BASE_DIR, 'cron', 'advisor-events.jsonl');
@@ -40,12 +41,15 @@ const NOTIFY_COOLDOWN_HOURS = 24;
 function loadState() {
     try {
         if (!existsSync(STATE_FILE))
-            return { notified: {} };
+            return { notified: {}, staleNotified: {} };
         const raw = JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
-        return { notified: raw.notified ?? {} };
+        return {
+            notified: raw.notified ?? {},
+            staleNotified: raw.staleNotified ?? {},
+        };
     }
     catch {
-        return { notified: {} };
+        return { notified: {}, staleNotified: {} };
     }
 }
 function saveState(state) {
@@ -470,6 +474,15 @@ export async function runFailureSweep(send, gateway, now = Date.now()) {
             logger.warn({ err }, 'Suspicious-run grading pre-pass failed (non-fatal)');
         }
     }
+    // SLA sweep runs unconditionally — catches jobs that silently stopped
+    // firing entirely, which the broken-job detector can't see because those
+    // jobs produce no error entries.
+    try {
+        await runSlaSweep(send, now);
+    }
+    catch (err) {
+        logger.warn({ err }, 'SLA sweep failed (non-fatal)');
+    }
     const broken = computeBrokenJobs(now);
     if (broken.length === 0) {
         // Clear cooldowns AND diagnostic cache entries for jobs that recovered.
@@ -545,6 +558,67 @@ export async function runFailureSweep(send, gateway, now = Date.now()) {
     }
     return fresh;
 }
+/**
+ * Detect and notify about jobs whose last run is >= SLA_MISSED_TICKS
+ * expected intervals old. Each stale job gets one notification per
+ * SLA_NOTIFY_COOLDOWN_HOURS window. Always emits cron_sla_breach to
+ * audit.jsonl regardless of cooldown so the trace record is complete.
+ */
+async function runSlaSweep(send, now) {
+    const stale = await computeStaleCronJobs(now);
+    if (stale.length === 0) {
+        // Clear cooldowns for jobs that recovered (are no longer stale).
+        const state = loadState();
+        let mutated = false;
+        for (const name of Object.keys(state.staleNotified)) {
+            if (!stale.find(s => s.jobName === name)) {
+                delete state.staleNotified[name];
+                mutated = true;
+            }
+        }
+        if (mutated)
+            saveState(state);
+        return;
+    }
+    // Emit audit events for every stale detection so downstream
+    // tooling (dashboards, alerts) has a complete record.
+    for (const job of stale) {
+        logAuditJsonl({
+            event_type: 'cron_sla_breach',
+            jobName: job.jobName,
+            agent_slug: job.agentSlug,
+            schedule: job.schedule,
+            lastRunAt: job.lastRunAt,
+            expectedIntervalMs: job.expectedIntervalMs,
+            overdueMinutes: job.overdueMinutes,
+        });
+    }
+    // Apply per-job notify cooldown so we don't spam.
+    const state = loadState();
+    const cooldownMs = SLA_NOTIFY_COOLDOWN_HOURS * 60 * 60 * 1000;
+    const fresh = [];
+    for (const job of stale) {
+        const prev = state.staleNotified[job.jobName];
+        if (prev && now - Date.parse(prev.lastNotifiedAt) < cooldownMs)
+            continue;
+        fresh.push(job);
+    }
+    if (fresh.length === 0)
+        return;
+    try {
+        await send(formatStaleReport(fresh));
+        const stamp = new Date(now).toISOString();
+        for (const job of fresh) {
+            state.staleNotified[job.jobName] = { lastNotifiedAt: stamp, lastRunAt: job.lastRunAt };
+        }
+        saveState(state);
+        appendAuditLog('sla_notified', fresh.map(j => j.jobName));
+        logger.info({ count: fresh.length, jobs: fresh.map(j => j.jobName) }, 'SLA monitor: notified owner about stale jobs');
+    }
+    catch (err) {
+        logger.warn({ err }, 'SLA monitor: notification dispatch failed');
+    }
+}
 function appendAuditLog(action, jobNames) {
     try {
         const auditPath = path.join(BASE_DIR, 'cron', 'failure-monitor.log');
@@ -606,4 +680,73 @@ async function loadJobPrompt(jobName) {
         return null;
     }
 }
+/** A job is "stale" if it has missed >= this many expected ticks. */
+const SLA_MISSED_TICKS = 3;
+/** Absolute floor so sub-hourly cron jobs don't alert too aggressively. */
+const SLA_MIN_OVERDUE_MS = 30 * 60 * 1000;
+/** Don't re-DM the owner about the same stale job within this window. */
+const SLA_NOTIFY_COOLDOWN_HOURS = 12;
+/**
+ * Walk enabled cron jobs and find ones that haven't run in at least
+ * SLA_MISSED_TICKS × their expected interval. Distinct from the broken-job
+ * detector which needs actual error entries — this catches the opposite
+ * failure mode: a job that silently stopped firing at all.
+ */
+export async function computeStaleCronJobs(now = Date.now()) {
+    const { parseCronJobs, parseAgentCronJobs, CronRunLog } = await import('./cron-scheduler.js');
+    const { AGENTS_DIR } = await import('../config.js');
+    const cronParser = await import('cron-parser');
+    const jobs = [...parseCronJobs(), ...parseAgentCronJobs(AGENTS_DIR)];
+    const runLog = new CronRunLog();
+    const stale = [];
+    for (const job of jobs) {
+        if (!job.enabled)
+            continue;
+        if (job.mode === 'unleashed')
+            continue; // one-shot, no recurring SLA
+        // Normalize schedule — node-cron accepts 6-field (with seconds) but
+        // cron-parser only takes 5-field.
+        const fields = job.schedule.trim().split(/\s+/);
+        const expr = fields.length === 6 ? fields.slice(1).join(' ') : job.schedule;
+        let intervalMs;
+        try {
+            const parser = cronParser.CronExpressionParser.parse(expr);
+            const next = parser.next().toDate().getTime();
+            const prev = parser.prev().toDate().getTime();
+            intervalMs = next - prev;
+        }
+        catch {
+            continue; // malformed schedule — separate concern
+        }
+        if (intervalMs <= 0)
+            continue;
+        const recent = runLog.readRecent(job.name, 1);
+        const lastRunAt = recent[0]?.startedAt ?? null;
+        const lastRunMs = lastRunAt ? Date.parse(lastRunAt) : 0;
+        const threshold = Math.max(intervalMs * SLA_MISSED_TICKS, SLA_MIN_OVERDUE_MS);
+        const sinceLastRun = now - lastRunMs;
+        if (sinceLastRun <= threshold)
+            continue;
+        stale.push({
+            jobName: job.name,
+            agentSlug: job.agentSlug,
+            schedule: job.schedule,
+            lastRunAt,
+            expectedIntervalMs: intervalMs,
+            overdueMinutes: Math.round((sinceLastRun - intervalMs) / 60_000),
+        });
+    }
+    return stale;
+}
+function formatStaleReport(stale) {
+    const lines = ['**Cron SLA breach — jobs that should have run but didn\'t:**', ''];
+    for (const job of stale) {
+        const last = job.lastRunAt ? `last ran ${new Date(job.lastRunAt).toISOString().slice(0, 16).replace('T', ' ')}` : 'never run';
+        const intervalMin = Math.round(job.expectedIntervalMs / 60_000);
+        lines.push(`- **${job.jobName}** (${job.schedule}, every ${intervalMin}m) — ${last}, overdue by ~${job.overdueMinutes}m`);
+    }
+    lines.push('');
+    lines.push('The scheduler may be stuck, the job may have thrown before logging, or it may have been silently disabled. Check the dashboard Scheduled Tasks panel.');
+    return lines.join('\n');
+}
 //# sourceMappingURL=failure-monitor.js.map

package/dist/gateway/router.d.ts

@@ -75,6 +75,13 @@ export declare class Gateway {
     constructor(assistant: PersonalAssistant);
     /** Get or create a session state entry. */
     private getSession;
+    /**
+     * Reverse-lookup the session key that owns a given deep-mode jobName.
+     * Used by the cron-scheduler callbacks so phase-progress and completion
+     * messages can be routed back to the originating channel instead of
+     * fanning out to every registered sender.
+     */
+    findDeepTaskSessionKey(jobName: string): string | null;
     getAgentManager(): AgentManager;
     getTeamRouter(): TeamRouter;
     getTeamBus(): TeamBus;

package/dist/gateway/router.js

@@ -322,6 +322,19 @@ export class Gateway {
         }
         return s;
     }
+    /**
+     * Reverse-lookup the session key that owns a given deep-mode jobName.
+     * Used by the cron-scheduler callbacks so phase-progress and completion
+     * messages can be routed back to the originating channel instead of
+     * fanning out to every registered sender.
+     */
+    findDeepTaskSessionKey(jobName) {
+        for (const [key, sess] of this.sessions) {
+            if (sess.deepTask?.jobName === jobName)
+                return key;
+        }
+        return null;
+    }
     // ── Team system accessors ──────────────────────────────────────────
     getAgentManager() {
         if (!this._agentManager) {

package/package.json

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