clementine-agent 1.18.10 → 1.18.11

package/dist/agent/assistant.js

@@ -1959,11 +1959,18 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 reason: bundles.length > 0 ? 'matched' : 'empty',
             };
         };
+        const autonomousToolRun = isHeartbeat || isCron || isPlanStep || isUnleashed;
         const promptToolRoute = routeToolSurface(promptScopeText);
         const profileToolRoute = routeToolSurface(profileScopeText);
         const contextToolRoute = routeToolSurface(contextRoutingText);
+        const promptHasToolRoute = promptToolRoute.fullSurface || promptToolRoute.bundles.length > 0;
+        const directFollowupNeedsContextTools = intentClassification?.type === 'followup'
+            || /^(yes|yep|yeah|go|go ahead|do it|continue|pick up|use that|run it|send it|same thing)\b/i.test(promptScopeText.trim());
+        const allowContextToolRoute = autonomousToolRun || (!promptHasToolRoute && directFollowupNeedsContextTools);
         const safeProfileToolRoute = profileToolRoute.fullSurface ? emptyToolRoute() : profileToolRoute;
-        const safeContextToolRoute = contextToolRoute.fullSurface ? emptyToolRoute() : contextToolRoute;
+        const safeContextToolRoute = allowContextToolRoute && !contextToolRoute.fullSurface
+            ? contextToolRoute
+            : emptyToolRoute();
         const toolRoute = mergeToolRoutes(promptToolRoute, mergeToolRoutes(safeProfileToolRoute, safeContextToolRoute));
         let allowedTools = [];
         const addAllowed = (...tools) => {
@@ -1977,10 +1984,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         };
         const scopeText = [
             directScopeText,
-            contextRoutingText,
+            allowContextToolRoute ? contextRoutingText : '',
         ].filter(Boolean).join('\n').toLowerCase();
         const promptScopeLower = promptScopeText.toLowerCase();
-        const autonomousToolRun = isHeartbeat || isCron || isPlanStep || isUnleashed;
         const taskIntent = intentClassification?.type === 'task' || autonomousToolRun;
         const memoryNeeded = autonomousToolRun
             || retrievalContext.trim().length > 0
@@ -3110,6 +3116,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // Flipped true on the first intervention; subsequent replies go through
         // un-validated (but still logged).
         let contradictionRetried = false;
+        let contextRecoveryRetries = 0;
         try {
             for (let attempt = 0; attempt <= PersonalAssistant.RATE_LIMIT_MAX_RETRIES; attempt++) {
                 const sdkOptions = await this.buildOptions({
@@ -3501,7 +3508,8 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             this.exchangeCounts.set(sessionKey, 0);
                             this._compactedSessions.delete(sessionKey);
                         }
-                        if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
+                        if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES && contextRecoveryRetries < 1) {
+                            contextRecoveryRetries++;
                             prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
                             preRotationSnapshot = null;
                             responseText = '';
@@ -3554,11 +3562,22 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 if (staleSession && attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
                     responseText = '';
                     if (contextRecovery) {
-                        prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
-                        preRotationSnapshot = null;
-                        contextRecovery = false;
+                        if (contextRecoveryRetries >= 1) {
+                            responseText = contextThrashRecoveryNotice();
+                            staleSession = false;
+                            contextRecovery = false;
+                        }
+                        else {
+                            contextRecoveryRetries++;
+                            prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
+                            preRotationSnapshot = null;
+                            contextRecovery = false;
+                            continue;
+                        }
+                    }
+                    else {
+                        continue;
                     }
-                    continue;
                 }
                 if (staleSession && contextRecovery && !responseText.trim()) {
                     responseText = contextThrashRecoveryNotice();
@@ -3588,11 +3607,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         this.exchangeCounts.set(sessionKey, 0);
                         this._compactedSessions.delete(sessionKey);
                     }
-                    if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
-                        prompt = buildContextRecoveredPrompt(prompt, {
-                            toolCalls: stallGuard?.getToolCalls() ?? [],
-                            partialText: '',
-                        });
+                    if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES && contextRecoveryRetries < 1) {
+                        contextRecoveryRetries++;
+                        prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
+                        preRotationSnapshot = null;
                         responseText = '';
                         continue;
                     }

package/dist/cli/index.js

@@ -264,6 +264,8 @@ async function cmdLaunch(options) {
     <string>${buildLaunchdPath()}</string>
     <key>CLEMENTINE_HOME</key>
     <string>${BASE_DIR}</string>
+    <key>CLEMENTINE_LAUNCHD_MANAGED</key>
+    <string>1</string>
   </dict>
 </dict>
 </plist>`;

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

@@ -0,0 +1,11 @@
+export interface CronDiagnosticRequest {
+    jobName: string;
+    wantsFix: boolean;
+}
+export declare function detectCronDiagnosticRequest(text: string, opts?: {
+    baseDir?: string;
+}): CronDiagnosticRequest | 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

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+const DIAGNOSTIC_RE = /\b(fix|repair|debug|diagnos(?:e|is|tic)?|what broke|why (?:did|is)|failed|failing|failure|broken|stuck|taking forever|too long|issue|problem)\b/i;
+function normalizeText(text) {
+    return text.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+function compactForMatch(text) {
+    return text
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .toLowerCase()
+        .match(/[a-z0-9]+/g)
+        ?.join('') ?? '';
+}
+function safeRunFileName(jobName) {
+    return jobName.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+function extractHyphenatedJobName(text) {
+    const match = text.match(/\b[a-z0-9]+(?:[-_:][a-z0-9]+){1,}\b/i);
+    if (!match)
+        return null;
+    const candidate = match[0].replace(/_/g, '-');
+    if (!candidate.includes('-') && !candidate.includes(':'))
+        return null;
+    return candidate;
+}
+function cleanYamlScalar(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function readCronEntriesFromFile(file, agentSlug) {
+    if (!existsSync(file))
+        return [];
+    try {
+        const raw = readFileSync(file, 'utf-8');
+        const allLines = raw.split('\n');
+        const entries = [];
+        for (let start = 0; start < allLines.length; start++) {
+            const line = allLines[start] ?? '';
+            const match = line.match(/^(\s*)-\s+name:\s*(.+?)\s*$/);
+            if (!match)
+                continue;
+            const indent = match[1].length;
+            const bareName = cleanYamlScalar(match[2]);
+            if (!bareName)
+                continue;
+            let end = allLines.length;
+            for (let i = start + 1; i < allLines.length; i++) {
+                const next = allLines[i] ?? '';
+                const nextMatch = next.match(/^(\s*)-\s+name:\s+/);
+                if (nextMatch && nextMatch[1].length === indent) {
+                    end = i;
+                    break;
+                }
+            }
+            const scalarLines = [];
+            for (const entryLine of allLines.slice(start, end)) {
+                if (/^\s+prompt:\s*/.test(entryLine))
+                    break;
+                if (/^\s+(- name:|schedule:|enabled:|tier:|mode:|max_hours:|max_turns:|max_retries:|agentSlug:|work_dir:|model:|timeout_ms:|always_deliver:)/.test(entryLine)) {
+                    scalarLines.push(entryLine.trim());
+                }
+            }
+            entries.push({
+                jobName: agentSlug ? `${agentSlug}:${bareName}` : bareName,
+                bareName,
+                ...(agentSlug ? { agentSlug } : {}),
+                scalarLines,
+            });
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+function collectCronJobConfigs(baseDir) {
+    const configs = readCronEntriesFromFile(path.join(baseDir, 'vault', '00-System', 'CRON.md'));
+    const agentsDir = path.join(baseDir, 'vault', '00-System', 'agents');
+    if (!existsSync(agentsDir))
+        return configs;
+    try {
+        for (const slug of readdirSync(agentsDir)) {
+            configs.push(...readCronEntriesFromFile(path.join(agentsDir, slug, 'CRON.md'), slug));
+        }
+    }
+    catch {
+        return configs;
+    }
+    return configs;
+}
+function configMatchesText(config, text) {
+    const compactText = compactForMatch(text);
+    const compactBare = compactForMatch(config.bareName);
+    const compactFull = compactForMatch(config.jobName);
+    if (compactBare.length >= 5 && compactText.includes(compactBare))
+        return true;
+    if (compactFull.length >= 5 && compactText.includes(compactFull))
+        return true;
+    const normalized = normalizeText(text);
+    const bare = config.bareName.toLowerCase();
+    const full = config.jobName.toLowerCase();
+    return normalized.includes(bare) || normalized.includes(full);
+}
+function resolveConfiguredJobName(text, baseDir) {
+    const matches = collectCronJobConfigs(baseDir)
+        .filter((config) => configMatchesText(config, text))
+        .sort((a, b) => compactForMatch(b.jobName).length - compactForMatch(a.jobName).length);
+    return matches[0]?.jobName ?? null;
+}
+export function detectCronDiagnosticRequest(text, opts = {}) {
+    const normalized = normalizeText(text);
+    if (!DIAGNOSTIC_RE.test(normalized))
+        return null;
+    const configuredJobName = opts.baseDir ? resolveConfiguredJobName(text, opts.baseDir) : null;
+    if (configuredJobName) {
+        return {
+            jobName: configuredJobName,
+            wantsFix: /\b(fix|repair)\b/i.test(normalized),
+        };
+    }
+    const explicit = extractHyphenatedJobName(text);
+    if (!explicit)
+        return null;
+    const hasCronContext = /\b(cron|job|task|run|runs|schedule|scheduled)\b/i.test(normalized);
+    if (!hasCronContext)
+        return null;
+    return {
+        jobName: explicit,
+        wantsFix: /\b(fix|repair)\b/i.test(normalized),
+    };
+}
+function readRecentRuns(baseDir, jobName, limit = 20) {
+    const file = path.join(baseDir, 'cron', 'runs', `${safeRunFileName(jobName)}.jsonl`);
+    if (!existsSync(file))
+        return [];
+    try {
+        return readFileSync(file, 'utf-8')
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .slice(-limit)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return {};
+            }
+        })
+            .filter((entry) => Object.keys(entry).length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function summarizeDuration(ms) {
+    if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0)
+        return 'unknown duration';
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    const seconds = Math.round(ms / 1000);
+    if (seconds < 90)
+        return `${seconds}s`;
+    const minutes = Math.round(seconds / 60);
+    return `${minutes}m`;
+}
+function oneLine(value, max = 220) {
+    return String(value ?? '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, max);
+}
+function isContextThrashRun(run) {
+    if (!run)
+        return false;
+    const text = `${run.terminalReason ?? ''} ${run.error ?? ''} ${run.outputPreview ?? ''}`;
+    return /rapid_refill_breaker|autocompact\s+is\s+thrashing|context\s+refilled\s+to\s+the\s+limit/i.test(text);
+}
+function isMaxTurnsRun(run) {
+    if (!run)
+        return false;
+    const text = `${run.terminalReason ?? ''} ${run.error ?? ''} ${run.outputPreview ?? ''}`;
+    return /max_turns|maximum number of turns/i.test(text);
+}
+function readCronScalarConfig(baseDir, jobName) {
+    const bareName = jobName.includes(':') ? jobName.split(':').slice(1).join(':') : jobName;
+    const config = collectCronJobConfigs(baseDir).find((entry) => entry.jobName === jobName || entry.bareName === bareName);
+    return config?.scalarLines ?? [];
+}
+export function buildCronDiagnosticResponse(text, opts = { baseDir: process.env.CLEMENTINE_HOME || '' }) {
+    const request = detectCronDiagnosticRequest(text, { baseDir: opts.baseDir });
+    if (!request || !opts.baseDir)
+        return null;
+    const runs = readRecentRuns(opts.baseDir, request.jobName, 20);
+    const latest = runs.at(-1);
+    const previousSuccess = runs.slice(0, -1).reverse().find((run) => run.status === 'ok' && !isContextThrashRun(run));
+    const config = readCronScalarConfig(opts.baseDir, request.jobName);
+    const lines = [
+        `I found ${request.jobName}. I am not running the job.`,
+    ];
+    if (!latest) {
+        lines.push('I do not see a run history file for that job yet, so there is nothing concrete to repair from logs.');
+        if (config.length > 0)
+            lines.push(`Current config: ${config.join(' | ')}`);
+        return lines.join('\n');
+    }
+    const latestLabel = [
+        latest.startedAt ? `started ${latest.startedAt}` : 'latest run',
+        latest.status ? `status ${latest.status}` : '',
+        latest.terminalReason ? `terminal ${latest.terminalReason}` : '',
+        summarizeDuration(latest.durationMs),
+    ].filter(Boolean).join(', ');
+    lines.push(`Latest run: ${latestLabel}.`);
+    if (previousSuccess?.startedAt) {
+        lines.push(`Last clean success I see: ${previousSuccess.startedAt} (${summarizeDuration(previousSuccess.durationMs)}).`);
+    }
+    if (config.length > 0) {
+        lines.push(`Current config: ${config.join(' | ')}.`);
+    }
+    if (isContextThrashRun(latest)) {
+        lines.push('Root cause: context overflow/autocompact thrash, not a downstream integration failure unless the run error says so. The job or diagnostic path is letting broad file reads, run history, or raw tool output fill the context window.');
+        lines.push('Safe fix: tighten the job prompt or add a job prompt override. Keep reads bounded, cap large record pulls to small batches, summarize raw JSON from temp files, and do not treat this as a max_turns-only fix for an unleashed job.');
+    }
+    else if (isMaxTurnsRun(latest)) {
+        lines.push('Root cause: the job hit its turn cap before finishing. A max_turns bump can help only if the output is already bounded.');
+    }
+    else if (latest.status === 'ok') {
+        lines.push('The latest run is recorded as ok. I would not change the job unless the delivered result was wrong.');
+    }
+    else {
+        const detail = oneLine(latest.error || latest.outputPreview);
+        lines.push(`Root cause from latest run: ${detail || 'the run failed without a useful error preview.'}`);
+    }
+    if (request.wantsFix) {
+        lines.push('Next change should be a config/prompt repair, not a retry. I should return this diagnosis quickly and only apply a bounded prompt/config patch when asked.');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=cron-diagnostic-turn.js.map

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

@@ -65,6 +65,7 @@ export interface Diagnosis {
     riskLevel: 'low' | 'medium' | 'high';
     generatedAt: string;
 }
+export declare function diagnoseKnownFailurePattern(broken: BrokenJob, jobDef: string | null, recentRuns: string): Diagnosis | null;
 /**
  * Diagnose one broken job. Returns a cached diagnosis if one exists and is
  * fresher than 24h; otherwise invokes the LLM. Always best-effort — returns

package/dist/gateway/failure-diagnostics.js

@@ -79,12 +79,18 @@ function readJobDefinition(jobName) {
             continue;
         try {
             const raw = readFileSync(file, 'utf-8');
-            // Find the YAML block for "- name: bareName" and return until the next
-            // "- name:" at the same indent or end of file.
-            const pattern = new RegExp(`^(  - name: ${bareName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$[\\s\\S]*?)(?=^  - name: |\\z)`, 'm');
-            const m = raw.match(pattern);
-            if (m)
-                return m[1].slice(0, 6000);
+            const lines = raw.split('\n');
+            const start = lines.findIndex((line) => line.trim() === `- name: ${bareName}`);
+            if (start === -1)
+                continue;
+            let end = lines.length;
+            for (let i = start + 1; i < lines.length; i++) {
+                if (/^  - name:\s+/.test(lines[i] ?? '')) {
+                    end = i;
+                    break;
+                }
+            }
+            return lines.slice(start, end).join('\n').slice(0, 6000);
         }
         catch { /* skip */ }
     }
@@ -117,10 +123,12 @@ function readRecentRuns(jobName, limit = 10) {
         const summaries = recent.map(line => {
             try {
                 const d = JSON.parse(line);
-                const detail = d.status === 'ok'
-                    ? `preview="${(d.outputPreview ?? '').slice(0, 120).replace(/\n/g, ' ')}"`
-                    : `error="${(d.error ?? '').split('\n')[0].slice(0, 160)}"`;
-                return `${d.startedAt} ${d.status} (${Math.round(d.durationMs / 1000)}s) ${detail}`;
+                const detailParts = [
+                    d.terminalReason ? `terminal=${d.terminalReason}` : '',
+                    d.error ? `error="${d.error.split('\n')[0].slice(0, 160)}"` : '',
+                    d.outputPreview ? `preview="${d.outputPreview.slice(0, 160).replace(/\n/g, ' ')}"` : '',
+                ].filter(Boolean);
+                return `${d.startedAt} ${d.status} (${Math.round(d.durationMs / 1000)}s) ${detailParts.join(' ')}`;
             }
             catch {
                 return line.slice(0, 160);
@@ -215,6 +223,101 @@ function buildPrompt(broken, jobDef, agentProfile, recentRuns) {
         '}',
     ].filter(Boolean).join('\n');
 }
+function bareJobName(jobName) {
+    return jobName.includes(':') ? jobName.split(':').slice(1).join(':') : jobName;
+}
+function promptOverrideForContextOverflow(jobName) {
+    return {
+        kind: 'prompt-override',
+        scope: 'job',
+        scopeKey: bareJobName(jobName),
+        content: [
+            '# Bounded Run Guidance',
+            '',
+            'Keep this job inside the context window.',
+            '- Do not read full CRON.md, full run histories, or raw integration exports.',
+            '- Pull records in batches of 20 or fewer unless the job prompt gives a smaller cap.',
+            '- Redirect large command/API output to temp files and summarize IDs, counts, names, statuses, and next actions only.',
+            '- Never paste raw integration, email, browser, tool, or other large JSON output into the conversation.',
+            '- If context starts filling, stop with a concise partial summary and pending list instead of retrying broad reads.',
+        ].join('\n'),
+    };
+}
+export function diagnoseKnownFailurePattern(broken, jobDef, recentRuns) {
+    const haystack = [
+        broken.jobName,
+        broken.lastAdvisorOpinion ?? '',
+        ...broken.lastErrors,
+        recentRuns,
+    ].join('\n').toLowerCase();
+    if (/rapid_refill_breaker|autocompact.*thrash|context refilled|prompt is too long|prompt too long|context.?length|maximum context|input is too long/.test(haystack)) {
+        const autoApply = jobDef ? promptOverrideForContextOverflow(broken.jobName) : undefined;
+        return {
+            rootCause: 'The job is overflowing the Claude context window. This is usually caused by broad file reads, full run-history reads, or raw integration output being pulled into the prompt.',
+            confidence: 'high',
+            proposedFix: {
+                type: autoApply ? 'prompt_override' : 'prompt_change',
+                details: 'Bound the job/diagnostic prompt: read tight chunks, cap batches at 20 records, summarize raw API output from temp files, and stop with a partial summary instead of retrying when context gets tight.',
+                ...(autoApply ? { autoApply } : {}),
+            },
+            riskLevel: 'low',
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    const maxTurns = haystack.match(/maximum number of turns\s*\(?(\d+)?\)?|max_turns/i);
+    if (maxTurns) {
+        const observed = Number(maxTurns[1]);
+        const next = Number.isFinite(observed) && observed > 0 ? Math.min(90, Math.max(15, observed * 3)) : 30;
+        return {
+            rootCause: 'The job reached its turn cap before finishing.',
+            confidence: 'high',
+            proposedFix: {
+                type: 'config_change',
+                details: `Raise max_turns to ${next} only if the prompt already keeps tool output bounded. If output is large, add bounded-output guidance first.`,
+                ...(jobDef ? {
+                    autoApply: {
+                        kind: 'cron',
+                        operations: [{ op: 'set', field: 'max_turns', value: next }],
+                    },
+                } : {}),
+            },
+            riskLevel: 'medium',
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    if (/\b(401|403)\b|not authenticated|invalid api key|credential|please run \/login|does not have access/.test(haystack)) {
+        return {
+            rootCause: 'The latest failures look credential-related.',
+            confidence: 'high',
+            proposedFix: {
+                type: 'credential_refresh',
+                details: 'Refresh the affected integration credentials, then run a small probe before re-enabling full job volume.',
+            },
+            riskLevel: 'low',
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    if (/no local bash|permission denied|blocked|task_blocked/.test(haystack)) {
+        const autoApply = jobDef ? {
+            kind: 'prompt-override',
+            scope: 'job',
+            scopeKey: bareJobName(broken.jobName),
+            content: 'Use only tools available to this agent. If local shell access is unavailable, report BLOCKED with the missing capability and do not retry the same unavailable tool.',
+        } : undefined;
+        return {
+            rootCause: 'The job appears to be selecting a tool or capability that is unavailable in its current agent scope.',
+            confidence: 'medium',
+            proposedFix: {
+                type: autoApply ? 'prompt_override' : 'agent_scope',
+                details: 'Tighten the job prompt or agent scope so it only uses available tools, and make unavailable-tool failures stop instead of looping.',
+                ...(autoApply ? { autoApply } : {}),
+            },
+            riskLevel: 'medium',
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    return null;
+}
 function parseResponse(raw) {
     try {
         // The model sometimes wraps the JSON in markdown fences; extract the
@@ -348,12 +451,24 @@ export async function diagnoseBrokenJob(broken, gateway) {
     const jobDef = readJobDefinition(broken.jobName);
     const agentProfile = broken.agentSlug ? readAgentProfile(broken.agentSlug) : null;
     const recentRuns = readRecentRuns(broken.jobName, 10);
+    const knownDiagnosis = diagnoseKnownFailurePattern(broken, jobDef, recentRuns);
+    if (knownDiagnosis) {
+        cache[broken.jobName] = knownDiagnosis;
+        saveCache(cache);
+        logger.info({
+            job: broken.jobName,
+            confidence: knownDiagnosis.confidence,
+            fixType: knownDiagnosis.proposedFix.type,
+        }, 'Broken-job diagnosis generated from known pattern');
+        return knownDiagnosis;
+    }
     const prompt = buildPrompt(broken, jobDef, agentProfile, recentRuns);
     let rawResponse;
     try {
         rawResponse = await gateway.handleCronJob(`diagnose:${broken.jobName}`, prompt, 1, // tier 1 — cheap
         5, // maxTurns — diagnosis doesn't need tools typically
-        'haiku');
+        'haiku', // model — keep cost negligible
+        undefined, 'standard', undefined, undefined, undefined, undefined, { disableAllTools: true });
     }
     catch (err) {
         logger.warn({ err, job: broken.jobName }, 'Diagnostic LLM call failed');

package/dist/gateway/router.js

@@ -20,6 +20,7 @@ import { events } from '../events/bus.js';
 import { listBackgroundTasks } from '../agent/background-tasks.js';
 import { applyAssistantExperienceUpdate, detectLocalTurn } from '../agent/local-turn.js';
 import { updateClementineJson } from '../config/clementine-json.js';
+import { buildCronDiagnosticResponse } from './cron-diagnostic-turn.js';
 const logger = pino({ name: 'clementine.gateway' });
 const INTERACTIVE_FAILURE_LOG = path.join(BASE_DIR, 'self-improve', 'interactive-failures.jsonl');
 /** Idle timeout for interactive chat messages (10 minutes).
@@ -1006,6 +1007,33 @@ export class Gateway {
             }, 'chat:latency');
             return localResponse;
         }
+        // Cron "what broke / fix this job" asks should not spin up a broad SDK
+        // session. They are bounded local diagnostics over run summaries and scalar
+        // config only, and they intentionally do not execute the cron job.
+        if (this.isTrustedPersonalSession(sessionKey)) {
+            const cronDiagnostic = buildCronDiagnosticResponse(text, { baseDir: BASE_DIR });
+            if (cronDiagnostic) {
+                const current = this.sessions.get(sessionKey);
+                if (current?.abortController && !current.abortController.signal.aborted) {
+                    current.abortController.abort('replaced-by-cron-diagnostic');
+                    logger.info({ sessionKey }, 'Interrupted active chat for local cron diagnostic');
+                }
+                if (onText) {
+                    try {
+                        await onText(cronDiagnostic);
+                    }
+                    catch { /* channel streaming is best-effort */ }
+                }
+                logger.info({
+                    sessionKey,
+                    totalMs: Date.now() - tInnerStart,
+                    chatMs: Date.now() - localTurnStarted,
+                    localCronDiagnostic: true,
+                    responseLen: cronDiagnostic.length,
+                }, 'chat:latency');
+                return cronDiagnostic;
+            }
+        }
         // Show "queued" status if either lane or session lock is contended,
         // so the user doesn't stare at "thinking..." for up to 60s while a
         // previous message is still processing.

package/dist/index.js

@@ -55,6 +55,9 @@ function killPid(pid) {
 function stopLaunchdService() {
     if (process.platform !== 'darwin')
         return false;
+    if (process.env.XPC_SERVICE_NAME === LAUNCHD_LABEL || process.env.CLEMENTINE_LAUNCHD_MANAGED === '1') {
+        return false;
+    }
     const home = process.env.HOME ?? '';
     const plist = path.join(home, 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
     if (!existsSync(plist))

package/package.json

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