clementine-agent 1.18.61 → 1.18.64

package/.env.example

@@ -36,6 +36,11 @@ WEBHOOK_SECRET=
 GROQ_API_KEY=
 ELEVENLABS_API_KEY=
 ELEVENLABS_VOICE_ID=
+VOICE_ENABLED=false
+VOICE_PROVIDER=gemini-live
+GEMINI_API_KEY=
+GEMINI_LIVE_MODEL=gemini-3.1-flash-live-preview
+GEMINI_LIVE_VOICE_NAME=Kore
 
 # ── Video (optional) ─────────────────────────────────────────────────
 GOOGLE_API_KEY=

package/dist/agent/agent-definitions.js

@@ -54,10 +54,10 @@ const CRON_FIXER_PROMPT = [
     'You are the cron-fix specialist. You diagnose and apply fixes to broken cron jobs.',
     '',
     'Workflow:',
-    '1. Call `list_broken_jobs` to see what is currently broken with their cached diagnoses.',
+    '1. If you already know the job name (parent named it, or notification context names it), call `cron_diagnose` first — it returns the bounded recent-run summary, phase status, and inferred root cause in one shot. If you need a list of currently failing jobs, call `list_broken_jobs` instead.',
     '2. For each job the user/parent asked about, check the proposed fix:',
     '   - confidence=high + risk=low + autoApply=true → call `apply_broken_job_fix`.',
-    '   - Otherwise → describe the diagnosis and ask the parent for explicit approval.',
+    '   - Otherwise → describe the diagnosis and ask the parent for explicit approval before any manual repair.',
     '3. After applying a fix, the verification system auto-rolls-back if the next 3 runs do not improve. You do NOT need to monitor manually.',
     '',
     'Return: a one-paragraph summary of what you applied (or what is blocking apply), per job.',
@@ -154,6 +154,7 @@ export function buildAgentMap(opts = {}) {
         prompt: CRON_FIXER_PROMPT,
         model: 'sonnet',
         tools: [
+            'mcp__clementine-tools__cron_diagnose',
             'mcp__clementine-tools__list_broken_jobs',
             'mcp__clementine-tools__apply_broken_job_fix',
             'mcp__clementine-tools__cron_list',

package/dist/cli/dashboard.js

@@ -181,9 +181,28 @@ async function getGateway() {
             dispatcher.register('dashboard', async (text, context) => {
                 if (!dashboardSseBroadcast)
                     return;
+                // Forward agent identity so the chat panel can render the
+                // originating hired agent's name + initial — same UX guarantee
+                // Discord/Slack already give via per-agent bot identities.
+                // agentSlug arrives populated by either the explicit caller
+                // (cron-scheduler.dispatchContextForJob etc.) or by the
+                // dispatcher's session-key inference safety net.
+                let agentName = null;
+                if (context?.agentSlug && context.agentSlug !== 'clementine') {
+                    try {
+                        const profile = gatewayInstance?.getAgentManager().get(context.agentSlug);
+                        agentName = profile?.name ?? null;
+                    }
+                    catch { /* best-effort — fall back to slug */ }
+                }
                 dashboardSseBroadcast({
                     type: 'deep_result',
-                    data: { sessionKey: context?.sessionKey ?? null, text },
+                    data: {
+                        sessionKey: context?.sessionKey ?? null,
+                        agentSlug: context?.agentSlug ?? null,
+                        agentName,
+                        text,
+                    },
                 });
             });
             gatewayInstance.setDispatcher(dispatcher);
@@ -19551,6 +19570,51 @@ let currentPage = 'home';
 var currentAgentSlug = null;
 var prevAgentSlugs = null;
 
+// Browser-side cache of /api/agents — feeds chat-bubble identity rendering
+// so a hired agent's response shows their name/initial instead of
+// Clementine's. Refreshed on profile switch + on deep_result events
+// where the cache is missing the slug. Same UX guarantee Discord/Slack
+// give via per-agent bot identities.
+var __teamAgentsByslug = {};
+var __teamAgentsLoadedAt = 0;
+async function ensureTeamAgentCache(force) {
+  if (!force && __teamAgentsLoadedAt && (Date.now() - __teamAgentsLoadedAt < 60_000)) return;
+  try {
+    var r = await apiFetch('/api/agents');
+    if (!r.ok) return;
+    var agents = await r.json();
+    var next = {};
+    if (Array.isArray(agents)) {
+      for (var i = 0; i < agents.length; i++) {
+        var a = agents[i];
+        if (a && a.slug) next[a.slug] = { slug: a.slug, name: a.name || a.slug, avatar: a.avatar || null };
+      }
+    }
+    __teamAgentsByslug = next;
+    __teamAgentsLoadedAt = Date.now();
+  } catch (e) { /* non-fatal — fall back to Clementine */ }
+}
+
+/**
+ * Resolve the display identity for an assistant chat bubble.
+ *
+ *   getAssistantIdentity()                    → active chat profile (or Clementine)
+ *   getAssistantIdentity(slugFromSseEvent)    → that specific agent
+ *
+ * Returns { slug, name, initial }. Always safe — falls back to
+ * Clementine when nothing matches. Initial is uppercase first char,
+ * suitable for a .chat-avatar-sm bubble.
+ */
+function getAssistantIdentity(explicitSlug) {
+  var slug = explicitSlug || currentAgentSlug || '';
+  if (slug && slug !== 'clementine' && __teamAgentsByslug[slug]) {
+    var a = __teamAgentsByslug[slug];
+    return { slug: a.slug, name: a.name, initial: (a.name || 'A').charAt(0).toUpperCase() };
+  }
+  var clemName = (lastStatusData && lastStatusData.name) ? lastStatusData.name : 'Clementine';
+  return { slug: 'clementine', name: clemName, initial: clemName.charAt(0).toUpperCase() };
+}
+
 // ── Routing ────────────────────────────────────────────────────
 //
 // Five top-level destinations: home, build, team, brain, settings.
@@ -24359,18 +24423,23 @@ async function sendChat() {
   sendBtn.textContent = 'Thinking...';
 
 	  try {
+	    // Identity follows the active chat profile so a hired agent's
+	    // reply renders with their initial — same as Discord/Slack.
+	    await ensureTeamAgentCache();
+	    var asstIdentity = getAssistantIdentity();
 	    var asstRow = document.createElement('div');
 	    asstRow.className = 'chat-assistant-row';
 	    var chatAv = document.createElement('div');
 	    chatAv.className = 'chat-avatar-sm';
-	    chatAv.innerHTML = (lastStatusData.name || 'C').charAt(0).toUpperCase();
+	    chatAv.title = asstIdentity.name;
+	    chatAv.innerHTML = asstIdentity.initial;
 	    asstRow.appendChild(chatAv);
 	    var asstBubble = document.createElement('div');
 	    asstBubble.className = 'chat-bubble assistant';
 	    asstBubble.innerHTML = '<span style="color:var(--text-muted);font-style:italic">connecting...</span>';
 	    var asstMeta = document.createElement('div');
 	    asstMeta.className = 'chat-meta';
-	    asstMeta.textContent = new Date().toLocaleTimeString();
+	    asstMeta.textContent = new Date().toLocaleTimeString() + (asstIdentity.slug !== 'clementine' ? ' · ' + asstIdentity.name : '');
 	    asstRow.appendChild(asstBubble);
 	    container.appendChild(asstRow);
 	    typing.remove();
@@ -32436,6 +32505,21 @@ try {
         try {
           var container = document.getElementById('chat-messages');
           var text = (evt.data && evt.data.text) ? evt.data.text : '';
+          // Identity from the SSE payload \u2014 server-side
+          // dashboard sender resolves agentSlug + agentName from
+          // the dispatcher context (cron jobs, hired-agent
+          // workflows, heartbeats), so a Sasha-cron completion
+          // renders with Sasha's initial + name in the meta line
+          // instead of looking like Clementine sent it. Falls
+          // back to Clementine when the event is unowned.
+          var deepSlug = (evt.data && evt.data.agentSlug) ? evt.data.agentSlug : null;
+          var deepName = (evt.data && evt.data.agentName) ? evt.data.agentName : null;
+          // Lazy-refresh the cache if the SSE event names a slug we
+          // haven't seen yet (e.g. an agent hired since page load).
+          if (deepSlug && !__teamAgentsByslug[deepSlug]) { ensureTeamAgentCache(true); }
+          var deepIdentity = deepName
+            ? { slug: deepSlug, name: deepName, initial: deepName.charAt(0).toUpperCase() }
+            : getAssistantIdentity(deepSlug);
           if (container && text) {
             var emptyState = container.querySelector('.empty-state');
             if (emptyState) emptyState.remove();
@@ -32443,20 +32527,24 @@ try {
             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();
+            av.title = deepIdentity.name;
+            av.innerHTML = deepIdentity.initial;
             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';
+            meta.textContent = new Date().toLocaleTimeString()
+              + (deepIdentity.slug && deepIdentity.slug !== 'clementine' ? ' \u00b7 ' + deepIdentity.name : '')
+              + ' \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');
+            var who = (deepIdentity.slug && deepIdentity.slug !== 'clementine') ? deepIdentity.name : 'Deep task';
+            toast(who + ' result ready \u2014 open chat to view.', 'info');
           }
         } catch(e) { /* non-fatal */ }
       }

package/dist/config.d.ts

@@ -132,6 +132,11 @@ export declare const WEBHOOK_BIND: string;
 export declare const GROQ_API_KEY: string;
 export declare const ELEVENLABS_API_KEY: string;
 export declare const ELEVENLABS_VOICE_ID: string;
+export declare const VOICE_ENABLED: boolean;
+export declare const VOICE_PROVIDER: string;
+export declare const GEMINI_API_KEY: string;
+export declare const GEMINI_LIVE_MODEL: string;
+export declare const GEMINI_LIVE_VOICE_NAME: string;
 export declare const GOOGLE_API_KEY: string;
 export declare const MS_TENANT_ID: string;
 export declare const MS_CLIENT_ID: string;

package/dist/config.js

@@ -467,6 +467,11 @@ export const WEBHOOK_BIND = getEnv('WEBHOOK_BIND', '127.0.0.1');
 export const GROQ_API_KEY = getSecret('GROQ_API_KEY');
 export const ELEVENLABS_API_KEY = getSecret('ELEVENLABS_API_KEY');
 export const ELEVENLABS_VOICE_ID = getEnv('ELEVENLABS_VOICE_ID');
+export const VOICE_ENABLED = getEnv('VOICE_ENABLED', 'false').toLowerCase() === 'true';
+export const VOICE_PROVIDER = getEnv('VOICE_PROVIDER', 'gemini-live');
+export const GEMINI_API_KEY = getSecret('GEMINI_API_KEY') || getSecret('GOOGLE_API_KEY');
+export const GEMINI_LIVE_MODEL = getEnv('GEMINI_LIVE_MODEL', 'gemini-3.1-flash-live-preview');
+export const GEMINI_LIVE_VOICE_NAME = getEnv('GEMINI_LIVE_VOICE_NAME', 'Kore');
 // ── Video ────────────────────────────────────────────────────────────
 export const GOOGLE_API_KEY = getSecret('GOOGLE_API_KEY');
 // ── Outlook (Microsoft Graph) ───────────────────────────────────────

package/dist/desktop/main.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Clementine desktop shell.
+ *
+ * This process owns a native Electron window and supervises the existing
+ * dashboard server. The dashboard remains the single UI source of truth.
+ */
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/desktop/main.js

@@ -0,0 +1,330 @@
+/**
+ * Clementine desktop shell.
+ *
+ * This process owns a native Electron window and supervises the existing
+ * dashboard server. The dashboard remains the single UI source of truth.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+function loadElectron() {
+    try {
+        return require('electron');
+    }
+    catch {
+        console.error('Electron is not installed. Run `npm install`, then `npm run desktop`.');
+        process.exit(1);
+    }
+}
+const electron = loadElectron();
+const { app, BrowserWindow, Menu, Tray, nativeImage, shell, dialog, session } = electron;
+app.setName('Clementine');
+if (app.setAppUserModelId)
+    app.setAppUserModelId('com.clementine.assistant');
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+const CLI_ENTRY = path.join(PACKAGE_ROOT, 'dist', 'cli', 'index.js');
+const ICONS_DIR = path.join(PACKAGE_ROOT, 'build', 'icons');
+const BASE_DIR = process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine');
+const DEFAULT_PORT = Number(process.env.CLEMENTINE_DESKTOP_PORT || process.env.DASHBOARD_PORT || 3030);
+const NODE_BINARY = process.env.CLEMENTINE_NODE_PATH || 'node';
+let mainWindow = null;
+let tray = null;
+let dashboardProcess = null;
+let dashboardUrl = `http://127.0.0.1:${DEFAULT_PORT}`;
+let observedPort = null;
+let isQuitting = false;
+let restartTimer = null;
+let suppressNextDashboardExitRestart = false;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function statusHtml(title, detail) {
+    const safeTitle = title.replace(/[<&>]/g, '');
+    const safeDetail = detail.replace(/[<&>]/g, '');
+    return 'data:text/html;charset=utf-8,' + encodeURIComponent('<!doctype html><html><head><meta charset="utf-8">' +
+        '<style>body{margin:0;height:100vh;display:flex;align-items:center;justify-content:center;' +
+        'font-family:-apple-system,BlinkMacSystemFont,Segoe UI,sans-serif;background:#111827;color:#f9fafb}' +
+        '.box{max-width:520px;padding:28px;text-align:center}.title{font-size:22px;font-weight:700;margin-bottom:10px}' +
+        '.detail{font-size:13px;line-height:1.5;color:#cbd5e1}</style></head><body><div class="box">' +
+        '<div class="title">' + safeTitle + '</div><div class="detail">' + safeDetail + '</div>' +
+        '</div></body></html>');
+}
+function loadStatus(title, detail) {
+    if (!mainWindow)
+        return;
+    mainWindow.loadURL(statusHtml(title, detail)).catch(() => undefined);
+}
+function resolveIconPath(name) {
+    const electronProcess = process;
+    const packagedRoot = typeof electronProcess.resourcesPath === 'string'
+        ? path.join(electronProcess.resourcesPath, 'build', 'icons')
+        : ICONS_DIR;
+    const candidates = [
+        path.join(ICONS_DIR, name),
+        path.join(packagedRoot, name),
+    ];
+    return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
+}
+function loadIcon(name) {
+    const icon = nativeImage.createFromPath(resolveIconPath(name));
+    return icon.isEmpty() ? nativeImage.createEmpty() : icon;
+}
+function probeDashboard(port) {
+    return new Promise((resolve) => {
+        const req = http.get({ hostname: '127.0.0.1', port, path: '/', timeout: 600 }, (res) => {
+            res.resume();
+            resolve(Boolean(res.statusCode && res.statusCode >= 200 && res.statusCode < 500));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.on('error', () => resolve(false));
+    });
+}
+async function waitForDashboard(startPort, timeoutMs = 25_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (observedPort && await probeDashboard(observedPort))
+            return observedPort;
+        for (let port = startPort; port < startPort + 10; port++) {
+            if (await probeDashboard(port))
+                return port;
+        }
+        await sleep(400);
+    }
+    throw new Error(`Dashboard did not become ready on ports ${startPort}-${startPort + 9}`);
+}
+async function findRunningDashboard(startPort) {
+    if (observedPort && await probeDashboard(observedPort))
+        return observedPort;
+    for (let port = startPort; port < startPort + 10; port++) {
+        if (await probeDashboard(port))
+            return port;
+    }
+    return null;
+}
+function attachDashboardLogs(child) {
+    const onChunk = (chunk) => {
+        const text = chunk.toString();
+        const match = text.match(/http:\/\/localhost:(\d+)/);
+        if (match)
+            observedPort = Number(match[1]);
+        if (process.env.CLEMENTINE_DESKTOP_DEBUG === '1')
+            process.stdout.write(text);
+    };
+    child.stdout?.on('data', onChunk);
+    child.stderr?.on('data', (chunk) => {
+        if (process.env.CLEMENTINE_DESKTOP_DEBUG === '1')
+            process.stderr.write(chunk);
+    });
+}
+function startDashboardProcess(port) {
+    if (!existsSync(CLI_ENTRY)) {
+        throw new Error(`Missing ${CLI_ENTRY}. Run npm run build before starting the desktop app.`);
+    }
+    observedPort = null;
+    const child = spawn(NODE_BINARY, [CLI_ENTRY, 'dashboard', '-p', String(port)], {
+        cwd: PACKAGE_ROOT,
+        env: {
+            ...process.env,
+            CLEMENTINE_HOME: BASE_DIR,
+            CLEMENTINE_NO_OPEN: '1',
+            __CLEM_DASHBOARD_CHILD: '1',
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    attachDashboardLogs(child);
+    child.on('exit', () => {
+        if (dashboardProcess === child)
+            dashboardProcess = null;
+        if (suppressNextDashboardExitRestart) {
+            suppressNextDashboardExitRestart = false;
+            return;
+        }
+        if (!isQuitting)
+            scheduleDashboardRestart();
+    });
+    return child;
+}
+async function startDashboardAndLoad() {
+    if (restartTimer) {
+        clearTimeout(restartTimer);
+        restartTimer = null;
+    }
+    loadStatus('Opening Clementine', 'Looking for the local dashboard...');
+    try {
+        const existingPort = await findRunningDashboard(DEFAULT_PORT);
+        if (existingPort) {
+            dashboardUrl = `http://127.0.0.1:${existingPort}`;
+            await mainWindow.loadURL(dashboardUrl);
+            return;
+        }
+        loadStatus('Starting Clementine', 'Opening the local dashboard server...');
+        if (!dashboardProcess)
+            dashboardProcess = startDashboardProcess(DEFAULT_PORT);
+        const actualPort = await waitForDashboard(DEFAULT_PORT);
+        dashboardUrl = `http://127.0.0.1:${actualPort}`;
+        await mainWindow.loadURL(dashboardUrl);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        loadStatus('Clementine is offline', message);
+        dialog.showErrorBox('Clementine desktop failed to start', message);
+    }
+}
+function scheduleDashboardRestart() {
+    loadStatus('Reconnecting', 'The dashboard process stopped. Restarting it now...');
+    if (restartTimer)
+        clearTimeout(restartTimer);
+    restartTimer = setTimeout(() => {
+        restartTimer = null;
+        startDashboardAndLoad().catch(() => undefined);
+    }, 1200);
+}
+function stopDashboard(suppressRestart = true) {
+    if (!dashboardProcess)
+        return;
+    const child = dashboardProcess;
+    dashboardProcess = null;
+    suppressNextDashboardExitRestart = suppressRestart;
+    try {
+        child.kill('SIGTERM');
+    }
+    catch { /* ignore */ }
+}
+function restartDashboard() {
+    stopDashboard(true);
+    setTimeout(() => {
+        startDashboardAndLoad().catch(() => undefined);
+    }, 700);
+}
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1280,
+        height: 860,
+        minWidth: 980,
+        minHeight: 680,
+        title: 'Clementine',
+        backgroundColor: '#111827',
+        icon: resolveIconPath('clementine.png'),
+        webPreferences: {
+            contextIsolation: true,
+            nodeIntegration: false,
+            sandbox: true,
+        },
+    });
+    mainWindow.on('close', (event) => {
+        if (isQuitting)
+            return;
+        event.preventDefault();
+        mainWindow.hide();
+    });
+    mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+        shell.openExternal(url).catch(() => undefined);
+        return { action: 'deny' };
+    });
+}
+function showWindow() {
+    if (!mainWindow)
+        createWindow();
+    mainWindow.show();
+    mainWindow.focus();
+}
+function installMenu() {
+    const template = [
+        {
+            label: 'Clementine',
+            submenu: [
+                { label: 'Show Clementine', click: showWindow },
+                { label: 'Open in Browser', click: () => shell.openExternal(dashboardUrl).catch(() => undefined) },
+                {
+                    label: 'Restart Dashboard',
+                    click: restartDashboard,
+                },
+                { type: 'separator' },
+                {
+                    label: 'Quit Clementine',
+                    accelerator: 'CmdOrCtrl+Q',
+                    click: () => {
+                        isQuitting = true;
+                        app.quit();
+                    },
+                },
+            ],
+        },
+        {
+            label: 'View',
+            submenu: [
+                { role: 'reload' },
+                { role: 'toggleDevTools' },
+                { type: 'separator' },
+                { role: 'resetZoom' },
+                { role: 'zoomIn' },
+                { role: 'zoomOut' },
+            ],
+        },
+    ];
+    Menu.setApplicationMenu(Menu.buildFromTemplate(template));
+}
+function installTray() {
+    const trayIcon = loadIcon(process.platform === 'darwin' ? 'trayTemplate.png' : 'tray.png');
+    tray = new Tray(trayIcon.isEmpty() ? loadIcon('tray.png') : trayIcon);
+    tray.setToolTip('Clementine');
+    tray.setContextMenu(Menu.buildFromTemplate([
+        { label: 'Show Clementine', click: showWindow },
+        { label: 'Restart Dashboard', click: restartDashboard },
+        { type: 'separator' },
+        { label: 'Quit', click: () => { isQuitting = true; app.quit(); } },
+    ]));
+    tray.on('click', showWindow);
+}
+function installPermissions() {
+    session.defaultSession.setPermissionRequestHandler((webContents, permission, callback) => {
+        const url = webContents.getURL?.() || '';
+        const local = url.startsWith('http://127.0.0.1:') || url.startsWith('http://localhost:');
+        callback(local && (permission === 'media' || permission === 'microphone'));
+    });
+}
+if (!app.requestSingleInstanceLock()) {
+    app.quit();
+}
+else {
+    app.on('second-instance', () => showWindow());
+    app.whenReady().then(() => {
+        const appIcon = loadIcon('clementine.png');
+        if (!appIcon.isEmpty() && app.dock)
+            app.dock.setIcon(appIcon);
+        if (app.setAboutPanelOptions) {
+            app.setAboutPanelOptions({
+                applicationName: 'Clementine',
+                applicationVersion: app.getVersion(),
+                iconPath: resolveIconPath('clementine.png'),
+            });
+        }
+        installPermissions();
+        installMenu();
+        installTray();
+        createWindow();
+        startDashboardAndLoad().catch(() => undefined);
+    });
+}
+app.on('activate', () => showWindow());
+app.on('before-quit', () => {
+    isQuitting = true;
+    if (tray) {
+        try {
+            tray.destroy();
+        }
+        catch { /* ignore */ }
+    }
+    stopDashboard();
+});
+//# sourceMappingURL=main.js.map

package/dist/gateway/cron-diagnostic-turn.d.ts

@@ -20,7 +20,4 @@ export declare function detectCronDiagnosticRequest(text: string, opts?: {
 export declare function buildCronDiagnosticResponseForRequest(request: CronDiagnosticRequest, opts?: {
     baseDir: string;
 }): string | null;
-export declare function buildCronDiagnosticResponse(text: string, opts?: {
-    baseDir: string;
-}): string | null;
 //# sourceMappingURL=cron-diagnostic-turn.d.ts.map

package/dist/gateway/cron-diagnostic-turn.js

@@ -274,10 +274,4 @@ export function buildCronDiagnosticResponseForRequest(request, opts = { baseDir:
     }
     return lines.join('\n');
 }
-export function buildCronDiagnosticResponse(text, opts = { baseDir: process.env.CLEMENTINE_HOME || '' }) {
-    const request = detectCronDiagnosticRequest(text, { baseDir: opts.baseDir });
-    if (!request || !opts.baseDir)
-        return null;
-    return buildCronDiagnosticResponseForRequest(request, opts);
-}
 //# sourceMappingURL=cron-diagnostic-turn.js.map

package/dist/gateway/cron-scheduler.d.ts

@@ -128,6 +128,27 @@ export declare class CronScheduler {
      * verification is pending and DMs the verdict if so.
      */
     private _logRun;
+    /**
+     * Single source of truth for the NotificationContext attached to any
+     * dispatch that originated from a cron job. Threads `agentSlug` (so
+     * the channel layer routes via the owning hired agent's bot when one
+     * exists) and a deterministic `sessionKey` (so the inference safety
+     * net at the dispatcher can recover routing if a future caller drops
+     * `agentSlug`). Use this — never construct contexts inline — so new
+     * dispatch sites in this file can't silently leak hired-agent results
+     * into Clementine's main DM.
+     */
+    private dispatchContextForJob;
+    /**
+     * Variant for dispatch sites that only have the job name in scope
+     * (MCP triggers, fix-verification, anywhere downstream of the run
+     * loop). Looks up the owning agentSlug from the live job table —
+     * falling back to a name-only context when the job is unknown
+     * (e.g. one-shot triggers without a CRON.md entry).
+     */
+    private dispatchContextForJobName;
+    /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
+    private dispatchContextForWorkflow;
     private runJob;
     /**
      * Log an advisor event to the events JSONL file for dashboard surfacing.