clementine-agent 1.18.154 → 1.18.156

package/dist/cli/dashboard.js

@@ -5136,21 +5136,33 @@ export async function cmdDashboard(opts) {
             res.status(500).json({ ok: false, error: String(err) });
         }
     });
-    app.post('/api/cron/migrate-all-to-skills', async (_req, res) => {
+    app.post('/api/cron/migrate-all-to-skills', async (req, res) => {
         try {
-            const { findMatchingSkill } = await import('../agent/cron-migrator.js');
-            const { listSkills } = await import('../agent/skill-store.js');
+            const { findMatchingSkill, generateDescription } = await import('../agent/cron-migrator.js');
+            const { listSkills, writeSkill } = await import('../agent/skill-store.js');
             const { setSchedule } = await import('../agent/schedule-registry.js');
             const { parseCronJobs, parseAgentCronJobs } = await import('../gateway/cron-scheduler.js');
+            // 1.18.156 — `createMissing` defaults true so the bulk path actually
+            // converts every legacy cron (auto-generates a folder-form skill from
+            // the cron prompt when no match exists). The user can still pass
+            // `{createMissing: false}` if they only want safe matches. .bak
+            // backups still happen either way.
+            const body = (req.body ?? {});
+            const createMissing = body.createMissing !== false;
             const skills = listSkills();
             const allJobs = [...parseCronJobs(), ...parseAgentCronJobs(path.join(VAULT_DIR, '00-System', 'agents'))];
             const legacy = allJobs.filter(j => j.source !== 'scheduled-skill');
             const migrated = [];
             const skipped = [];
+            // Track names we've just created so subsequent jobs in the loop don't
+            // bail with "skill not in catalog" before listSkills() refreshes.
+            const createdThisPass = new Set();
+            const inCatalog = (n) => createdThisPass.has(n) || skills.some(s => s.frontmatter.name === n);
             // Group by source CRON.md so we open + parse + write each file once.
             const byFile = new Map();
             for (const job of legacy) {
                 let skillName = null;
+                let created = false;
                 if (job.skills && job.skills.length > 0) {
                     skillName = job.skills.find(s => skills.some(sk => sk.frontmatter.name === s)) ?? null;
                 }
@@ -5160,10 +5172,49 @@ export async function cmdDashboard(opts) {
                         skillName = m.frontmatter.name;
                 }
                 if (!skillName) {
-                    skipped.push({ name: job.name, reason: 'no skill match' });
-                    continue;
+                    if (!createMissing) {
+                        skipped.push({ name: job.name, reason: 'no skill match (set createMissing=true to auto-create)' });
+                        continue;
+                    }
+                    // Auto-create a skill from the cron's prompt. Mirrors the per-row
+                    // /migrate-with-skill-creation endpoint logic.
+                    const candidate = job.name
+                        .toLowerCase().replace(/[_\s]+/g, '-').replace(/[^a-z0-9-]/g, '')
+                        .replace(/-+/g, '-').replace(/^-+|-+$/g, '')
+                        .replace(/-(cron|task|job)$/, '').slice(0, 64);
+                    if (!candidate || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(candidate) || inCatalog(candidate)) {
+                        skipped.push({ name: job.name, reason: `cannot derive a unique kebab-case name (candidate: "${candidate}")` });
+                        continue;
+                    }
+                    const cronPrompt = String(job.prompt || '').trim();
+                    const desc = generateDescription(cronPrompt, null);
+                    const triggerPhrase = job.name.replace(/-/g, ' ');
+                    const description = `${desc} Use when this scheduled task fires (cron: ${job.schedule}) or when the user mentions "${triggerPhrase}".`.slice(0, 1024);
+                    try {
+                        writeSkill({
+                            name: candidate,
+                            description,
+                            body: [
+                                `# ${candidate.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase())}`,
+                                '', '## Instructions', '',
+                                cronPrompt || '(prompt not captured — fill in)',
+                                '', '## When to use', '',
+                                `Auto-fired on schedule \`${job.schedule}\`. Also matches user prompts about "${triggerPhrase}".`,
+                                '',
+                            ].join('\n'),
+                            source: 'imported',
+                            ...(job.agentSlug ? { agentSlug: job.agentSlug } : {}),
+                        });
+                        createdThisPass.add(candidate);
+                        skillName = candidate;
+                        created = true;
+                    }
+                    catch (writeErr) {
+                        skipped.push({ name: job.name, reason: `skill auto-create failed: ${String(writeErr)}` });
+                        continue;
+                    }
                 }
-                if (!skills.some(s => s.frontmatter.name === skillName)) {
+                if (!inCatalog(skillName)) {
                     skipped.push({ name: job.name, reason: `skill "${skillName}" not in catalog` });
                     continue;
                 }
@@ -5173,7 +5224,7 @@ export async function cmdDashboard(opts) {
                         enabled: job.enabled !== false,
                         agentSlug: job.agentSlug ?? null,
                     });
-                    migrated.push({ name: job.name, skillName });
+                    migrated.push({ name: job.name, skillName, ...(created ? { created: true } : {}) });
                     const { cronFile, bareJobName } = resolveJobCronFile(job.name);
                     if (!byFile.has(cronFile))
                         byFile.set(cronFile, { jobsToRemove: new Set(), cronFile });
@@ -5217,6 +5268,136 @@ export async function cmdDashboard(opts) {
             res.status(500).json({ ok: false, error: String(err) });
         }
     });
+    // 1.18.156 — Per-row "create skill from this cron prompt + schedule it"
+    // path. The user's legacy crons usually have no matching skill (so the
+    // existing /api/cron/:job/migrate-to-skill aborts with "Create a skill
+    // first"). This endpoint closes that gap by writing a folder-form
+    // SKILL.md from the cron's prompt, then performing the schedule wire-up
+    // in one shot. Anthropic-canonical: name = kebab-case, description has
+    // WHAT + WHEN + first-sentence trigger phrase, body is the cron prompt
+    // verbatim. The user can immediately refine via the Builder afterward.
+    app.post('/api/cron/:job/migrate-with-skill-creation', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job name required' });
+                return;
+            }
+            const proposedName = String((req.body && req.body.skillName) || '').trim();
+            const { generateDescription } = await import('../agent/cron-migrator.js');
+            const { writeSkill, listSkills } = await import('../agent/skill-store.js');
+            const { setSchedule } = await import('../agent/schedule-registry.js');
+            const { parseCronJobs, parseAgentCronJobs } = await import('../gateway/cron-scheduler.js');
+            const { cronFile, bareJobName } = resolveJobCronFile(jobName);
+            const allJobs = [...parseCronJobs(), ...parseAgentCronJobs(path.join(VAULT_DIR, '00-System', 'agents'))];
+            const target = allJobs.find(j => String(j.name).toLowerCase() === jobName.toLowerCase());
+            if (!target)
+                return res.status(404).json({ ok: false, error: `job "${jobName}" not found` });
+            if (target.source === 'scheduled-skill') {
+                return res.status(400).json({ ok: false, error: 'already a scheduled skill' });
+            }
+            // Slugify proposed name (or fall back to the job name) to Anthropic's
+            // kebab-case convention. Strip "cron"/"task" suffixes that don't add
+            // meaning; cap at 64 chars per the SKILL.md spec.
+            const rawName = proposedName || jobName;
+            const skillName = rawName
+                .toLowerCase()
+                .replace(/[_\s]+/g, '-')
+                .replace(/[^a-z0-9-]/g, '')
+                .replace(/-+/g, '-')
+                .replace(/^-+|-+$/g, '')
+                .replace(/-(cron|task|job)$/, '')
+                .slice(0, 64);
+            if (!skillName || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(skillName)) {
+                return res.status(400).json({ ok: false, error: `cannot derive a valid kebab-case skill name from "${rawName}"` });
+            }
+            // Collision check.
+            const existing = listSkills();
+            if (existing.some(s => s.frontmatter.name === skillName)) {
+                return res.status(409).json({
+                    ok: false,
+                    error: `Skill "${skillName}" already exists. Pass a different skillName or use /migrate-to-skill to bind to it.`,
+                });
+            }
+            // Build an Anthropic-canonical SKILL.md. Description follows the
+            // WHAT + WHEN pattern from the PDF (page 11): start with what the
+            // cron does, add a trigger phrase derived from the cron name.
+            const cronPrompt = String(target.prompt || '').trim();
+            const cleanedDesc = generateDescription(cronPrompt, null);
+            const triggerPhrase = jobName.replace(/-/g, ' ');
+            const description = `${cleanedDesc} Use when this scheduled task fires (cron: ${target.schedule}) or when the user mentions "${triggerPhrase}".`.slice(0, 1024);
+            const body = [
+                `# ${skillName.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase())}`,
+                '',
+                '## Instructions',
+                '',
+                cronPrompt || '(prompt not captured — fill in)',
+                '',
+                '## When to use',
+                '',
+                `Auto-fired on schedule \`${target.schedule}\`. Also matches user prompts about "${triggerPhrase}".`,
+                '',
+            ].join('\n');
+            let writeResult;
+            try {
+                writeResult = writeSkill({
+                    name: skillName,
+                    description,
+                    body,
+                    source: 'imported',
+                    ...(target.agentSlug ? { agentSlug: target.agentSlug } : {}),
+                });
+            }
+            catch (writeErr) {
+                return res.status(500).json({ ok: false, error: `skill write failed: ${String(writeErr)}` });
+            }
+            // Now wire the schedule pointing at the new skill.
+            const entry = setSchedule(skillName, {
+                schedule: target.schedule,
+                enabled: target.enabled !== false,
+                agentSlug: target.agentSlug ?? null,
+            });
+            // Remove the legacy cron entry. Same .bak + write-back pattern as the
+            // canonical /migrate-to-skill endpoint.
+            const bakPath = cronFile + '.bak';
+            try {
+                writeFileSync(bakPath, readFileSync(cronFile, 'utf-8'));
+            }
+            catch { /* best-effort */ }
+            const { parsed, jobs } = readCronFileAt(cronFile);
+            const idx = jobs.findIndex(j => String(j.name).toLowerCase() === bareJobName.toLowerCase());
+            if (idx >= 0) {
+                jobs.splice(idx, 1);
+                writeCronFileAt(cronFile, parsed, jobs);
+            }
+            try {
+                const gw = await getGateway();
+                const sched = gw.cronScheduler;
+                if (sched && typeof sched.reloadJobs === 'function')
+                    sched.reloadJobs();
+            }
+            catch { /* best-effort */ }
+            try {
+                broadcastEvent({ type: 'skill_created', data: { skillName, fromCron: jobName } });
+            }
+            catch { /* non-fatal */ }
+            try {
+                broadcastEvent({ type: 'cron_deleted', data: { job: jobName, source: 'cron-md', migrated: true } });
+            }
+            catch { /* non-fatal */ }
+            res.json({
+                ok: true,
+                skillName,
+                scheduleEntry: entry,
+                skillPath: writeResult.filePath,
+                bakPath,
+                message: `Created skill "${skillName}" and scheduled it on ${target.schedule}. Cron entry removed (backup: ${bakPath}).`,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
     app.post('/api/cron/migrate-all', async (_req, res) => {
         try {
             const { migrateAllEligibleJobs } = await import('../agent/cron-migrator.js');
@@ -25418,8 +25599,18 @@ function renderScheduledTaskCard(task) {
   } else {
     badges += '<span class="badge badge-gray" title="Legacy CRON.md job. Carries its own prompt/tools/MCP. Convert to a scheduled skill when you can.">LEGACY CRON</span>';
   }
-  if (task.predictable === true) badges += '<span class="badge badge-green" title="Contract mode — runs with only the prompt + pinned skills/tools. No MEMORY.md, no auto-matched skills, no team comms injection at fire-time.">🔒 predictable</span>';
-  else if (task.predictable === false) badges += '<span class="badge badge-yellow" title="Dynamic mode — fire-time injects MEMORY.md, recent team activity, and auto-matched skills. Can drift from chat-time intent.">🔄 reads memory</span>';
+  // 1.18.155 — replace the "🔒 predictable" lock icon (which appeared on
+  // ~every row and added pure noise) with a single "Strict" pill that ONLY
+  // appears when behavior diverges from the default. predictable=true is
+  // the default for new tasks since 1.18.68, so suppress that badge — only
+  // show one when the user has explicitly opted into dynamic mode (the
+  // less safe path, worth flagging) or when lean mode is in effect for a
+  // meta-job (worth showing because it explains why the prompt is small).
+  if (task.lean === true) {
+    badges += '<span class="badge badge-purple" title="Lean envelope — drops every auto-injected context block (memory, progress, goal, criteria, skills) and prunes the MCP catalog. Used for meta-jobs that must stay under Haiku\'s prompt cap.">Lean</span>';
+  } else if (task.predictable === false) {
+    badges += '<span class="badge badge-yellow" title="Dynamic mode — fire-time injects MEMORY.md, recent team activity, and auto-matched skills. Can drift from chat-time intent.">Reads memory</span>';
+  }
   if (task.mode === 'unleashed') badges += '<span class="badge badge-purple">long-running</span>';
   if (task.after) badges += '<span class="badge badge-yellow" title="Triggered after ' + esc(task.after) + '">after ' + esc(task.after) + '</span>';
   if (task.maxRetries != null) badges += '<span class="badge badge-gray">' + esc(task.maxRetries) + ' retries</span>';
@@ -25488,42 +25679,82 @@ function renderScheduledTaskCard(task) {
 }
 
 // 1.18.132 — Phase 3 migrator: convert one legacy cron → scheduled skill.
-// Calls /api/cron/:job/migrate-to-skill which writes schedules.json and
-// removes the entry from CRON.md (with a .bak backup).
+// 1.18.156 — End-to-end migration: try /migrate-to-skill first; if the
+// backend bails with "no skill match" (the common case for the user's
+// 15 legacy crons), surface a confirm to CREATE the skill from the cron's
+// prompt and schedule it in one shot via /migrate-with-skill-creation.
+// Replaces the silent-failure UX where the button did nothing visible.
 async function migrateCronToSkillFromCard(jobName) {
   if (!confirm('Convert "' + jobName + '" to a scheduled skill?\\n\\n' +
-    'This writes a thin entry in ~/.clementine/schedules.json that points to a skill, ' +
-    'and removes the legacy fat-cron entry from CRON.md. ' +
-    'A .bak backup is left so you can restore if anything looks wrong.')) return;
+    'This writes a thin entry in ~/.clementine/schedules.json pointing to a skill, ' +
+    'and removes the legacy fat-cron entry from CRON.md. A .bak backup is left.')) return;
   try {
     var r = await apiFetch('/api/cron/' + encodeURIComponent(jobName) + '/migrate-to-skill', { method: 'POST' });
     var d = await r.json();
-    if (!r.ok) { toast(d.error || 'Migration failed', 'error'); return; }
-    toast('Migrated "' + jobName + '" → scheduled skill "' + d.skillName + '"', 'success');
-    if (typeof refreshCron === 'function') refreshCron();
+    if (r.ok) {
+      toast('Migrated "' + jobName + '" → scheduled skill "' + d.skillName + '"', 'success');
+      if (typeof refreshCron === 'function') refreshCron();
+      return;
+    }
+    // Common path: no matching skill exists. Offer to auto-create one.
+    var msg = d.error || '';
+    if (msg.indexOf('No skill match') >= 0 || msg.indexOf('not in catalog') >= 0) {
+      var proceed = confirm(
+        'No matching skill found for "' + jobName + '".\\n\\n' +
+        'Want me to create a folder-form skill from this cron\\x27s prompt and schedule it?\\n\\n' +
+        '• The skill is named after the cron (kebab-case)\\n' +
+        '• Description follows Anthropic\\x27s WHAT + WHEN format\\n' +
+        '• The cron prompt becomes the skill body — refine it later in the Builder\\n' +
+        '• The legacy cron is removed (with .bak backup)'
+      );
+      if (!proceed) { toast('Migration cancelled — no skill created', 'info'); return; }
+      var r2 = await apiFetch('/api/cron/' + encodeURIComponent(jobName) + '/migrate-with-skill-creation', { method: 'POST' });
+      var d2 = await r2.json();
+      if (!r2.ok) { toast(d2.error || 'Skill creation + migration failed', 'error'); return; }
+      toast('Created skill "' + d2.skillName + '" + scheduled it. Refine in the Builder when ready.', 'success');
+      if (typeof refreshCron === 'function') refreshCron();
+      if (typeof refreshSkills === 'function') refreshSkills();
+      return;
+    }
+    toast(msg || 'Migration failed', 'error');
   } catch (err) {
     toast('Failed: ' + err, 'error');
   }
 }
 
-// Bulk migrator from the deprecation banner. Migrates every legacy cron
-// that has a matching skill; reports skipped ones with reasons.
+// 1.18.156 — Bulk migrator. Default behavior auto-creates a folder-form
+// skill for any cron that has no matching skill (createMissing=true),
+// because the user's 15 legacy crons typically have no match — without
+// auto-create, the bulk button silently skips everything. .bak backups
+// preserve every original CRON.md so rollback is one cp away.
 async function migrateAllCronsToSkills() {
-  if (!confirm('Convert ALL eligible legacy crons to scheduled skills?\\n\\n' +
-    'Each cron with a matched skill will become a thin schedules.json entry. ' +
-    'CRON.md files get .bak backups. Crons without a skill match are skipped — ' +
-    'no data loss.')) return;
+  if (!confirm('Convert ALL legacy crons to scheduled skills?\\n\\n' +
+    'For each cron:\\n' +
+    '• If a matching skill exists → bind to it\\n' +
+    '• If no matching skill → auto-create one (kebab-case, Anthropic format) from the cron prompt\\n\\n' +
+    'CRON.md files get .bak backups. Refine generated skills in the Builder afterwards.')) return;
   try {
-    var r = await apiFetch('/api/cron/migrate-all-to-skills', { method: 'POST' });
+    var r = await apiFetch('/api/cron/migrate-all-to-skills', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ createMissing: true }),
+    });
     var d = await r.json();
     if (!r.ok) { toast(d.error || 'Bulk migration failed', 'error'); return; }
-    var migrated = (d.migrated || []).length;
+    var migrated = d.migrated || [];
+    var created = migrated.filter(function(m) { return m.created; }).length;
+    var bound = migrated.length - created;
     var skipped = (d.skipped || []).length;
-    var msg = 'Migrated ' + migrated + ' cron' + (migrated === 1 ? '' : 's') + ' to scheduled skills';
+    var parts = [];
+    if (bound > 0) parts.push(bound + ' bound to existing skill' + (bound === 1 ? '' : 's'));
+    if (created > 0) parts.push(created + ' new skill' + (created === 1 ? '' : 's') + ' created');
+    var msg = 'Migrated ' + migrated.length + ' cron' + (migrated.length === 1 ? '' : 's')
+      + (parts.length ? ' (' + parts.join(', ') + ')' : '');
     if (skipped > 0) msg += '. ' + skipped + ' skipped — see console for reasons.';
-    toast(msg, migrated > 0 ? 'success' : 'info');
+    toast(msg, migrated.length > 0 ? 'success' : 'info');
     if (skipped > 0 && d.skipped) console.warn('[migrate-all-to-skills] skipped:', d.skipped);
     if (typeof refreshCron === 'function') refreshCron();
+    if (typeof refreshSkills === 'function') refreshSkills();
   } catch (err) {
     toast('Failed: ' + err, 'error');
   }
@@ -25670,7 +25901,13 @@ function renderRecentHistoryList(runs) {
       var msg = String(entry.error).slice(0, 120);
       errorPreview = '<div style="font-size:11px;color:var(--red);margin-top:2px;word-break:break-word">' + esc(msg) + '</div>';
     } else if (entry.outputPreview) {
-      var preview = String(entry.outputPreview).slice(0, 140);
+      // 1.18.155 — strip the __NOTHING__ sentinel agents emit when they
+      // intentionally stay silent (it's the "no signal" contract from
+      // run-agent-cron.ts howToRespond block, not output the user should see).
+      var rawPreview = String(entry.outputPreview);
+      var preview = (rawPreview === '__NOTHING__' || rawPreview.trim() === '__NOTHING__')
+        ? '(no output — agent reported nothing worth saying)'
+        : rawPreview.slice(0, 140);
       errorPreview = '<div style="font-size:11px;color:var(--text-muted);margin-top:2px;word-break:break-word">' + esc(preview) + '</div>';
     }
     // PRD Phase 1.1: goal cell. Empty cell when no goal configured (status='skipped'
@@ -25775,16 +26012,31 @@ async function refreshHealthStrip() {
     var ops = await apiFetch('/api/build/operations?hours=1&limit=10').then(function(rr) { return rr.json(); });
     activeRuns = ((ops && ops.runningNow) || []).length;
   } catch (e) { /* fall back to 0 */ }
-  // Top failure category for the day.
+  // Top failure category for the day. 1.18.155 — when no failureCategory
+  // is set on the failed runs (which is common for raw SDK errors like
+  // "Prompt is too long"), fall back to grouping by jobName so the user
+  // sees WHICH job is failing instead of a useless dash. Categories still
+  // win when present (more semantic than a job name).
   var catCounts = {};
+  var jobCounts = {};
   for (var i = 0; i < last24.length; i++) {
     var c = last24[i].failureCategory;
     if (c) catCounts[c] = (catCounts[c] || 0) + 1;
+    if (last24[i].status === 'error' || last24[i].status === 'failed') {
+      var jn = last24[i].jobName || last24[i].name;
+      if (jn) jobCounts[jn] = (jobCounts[jn] || 0) + 1;
+    }
   }
   var topCat = null, topCount = 0;
   Object.keys(catCounts).forEach(function(k) {
     if (catCounts[k] > topCount) { topCat = k; topCount = catCounts[k]; }
   });
+  var topJob = null, topJobCount = 0;
+  Object.keys(jobCounts).forEach(function(k) {
+    if (jobCounts[k] > topJobCount) { topJob = k; topJobCount = jobCounts[k]; }
+  });
+  // Prefer the categorized one (more semantic), fall back to job name.
+  if (!topCat && topJob) { topCat = topJob; topCount = topJobCount; }
   // Render six tiles.
   function tile(label, value, sub, color) {
     return '<div class="health-tile">'
@@ -26450,7 +26702,12 @@ function renderRunListBody(allRuns) {
     if (status === 'error' && entry.error) {
       preview = '<div style="font-size:11px;color:var(--red);margin-top:2px;word-break:break-word">' + esc(String(entry.error).slice(0, 140)) + '</div>';
     } else if (entry.outputPreview) {
-      preview = '<div style="font-size:11px;color:var(--text-muted);margin-top:2px;word-break:break-word">' + esc(String(entry.outputPreview).slice(0, 120)) + '</div>';
+      // 1.18.155 — see renderRecentHistoryList for the same __NOTHING__ strip.
+      var rawOp = String(entry.outputPreview);
+      var opText = (rawOp === '__NOTHING__' || rawOp.trim() === '__NOTHING__')
+        ? '(no output — agent reported nothing worth saying)'
+        : rawOp.slice(0, 120);
+      preview = '<div style="font-size:11px;color:var(--text-muted);margin-top:2px;word-break:break-word">' + esc(opText) + '</div>';
     }
     // 1.18.89: cost label. Showing 4 decimals for sub-penny costs (Haiku
     // runs land in fractions of a cent), 2 decimals when ≥ $0.01.
@@ -27079,7 +27336,11 @@ async function refreshCron() {
     var bannerHtml = '';
     var dismissed = localStorage.getItem('clem-skill-migrate-banner-dismissed') === '1';
     if (legacyCount > 0 && !dismissed) {
-      bannerHtml = '<div style="background:rgba(124,58,237,0.08);border:1px solid var(--purple);border-radius:8px;padding:12px 14px;margin-bottom:14px;display:flex;align-items:center;gap:12px;flex-wrap:wrap">'
+      // 1.18.155 — data-banner-kind tags this as the legacy-cron soft-
+      // deprecation banner so refreshCronMigrateBanner can suppress its
+      // secondary "clean up preambles" banner when this one is showing
+      // (full migration is a superset; showing both is confusing noise).
+      bannerHtml = '<div data-banner-kind="legacy-cron-soft-deprecation" style="background:rgba(124,58,237,0.08);border:1px solid var(--purple);border-radius:8px;padding:12px 14px;margin-bottom:14px;display:flex;align-items:center;gap:12px;flex-wrap:wrap">'
         + '<span style="font-size:18px">⚡</span>'
         + '<div style="flex:1;min-width:200px">'
         +   '<div style="font-size:13px;font-weight:500;color:var(--text-primary)">' + legacyCount + ' legacy cron task' + (legacyCount === 1 ? '' : 's') + ' can become scheduled skills</div>'
@@ -29049,6 +29310,19 @@ async function refreshCronMigrateBanner() {
       return;
     }
     _cronMigratePreview = d;
+    // 1.18.155 — suppress this banner when the upstream "X legacy crons
+    // can become scheduled skills" banner is already showing. The full
+    // migration there is a superset of this cleanup (the destination skill
+    // gets a clean prompt automatically), so showing both at once is just
+    // confusing noise. If the upstream banner is dismissed via localStorage
+    // OR there are no legacy crons to migrate, this orange banner shows up
+    // as the secondary action.
+    var dismissed = localStorage.getItem('clem-skill-migrate-banner-dismissed') === '1';
+    var hasLegacyCronBanner = !dismissed && document.querySelector('[data-banner-kind="legacy-cron-soft-deprecation"]');
+    if (hasLegacyCronBanner) {
+      host.innerHTML = '';
+      return;
+    }
     var n = d.eligible.length;
     host.innerHTML =
       '<div style="margin:0 0 14px;padding:12px 16px;border:1px solid var(--accent);background:rgba(255,141,0,0.06);border-radius:8px;display:flex;align-items:center;gap:14px;flex-wrap:wrap">'

package/dist/dashboard/build-operations.d.ts

@@ -101,6 +101,10 @@ export interface ScheduledTaskCard {
      *  team comms / auto-matched skills. The visibility-on-card flag for
      *  "this trick will run with only what you see here." */
     predictable?: boolean;
+    /** 1.18.154/155 — Lean envelope (meta-jobs). Surfaced in the row badge
+     *  so the user understands why insight-check / outcome-grader / etc.
+     *  show a tiny prompt + restricted MCP catalog. */
+    lean?: boolean;
 }
 export interface ScheduledWorkflowCard {
     type: 'scheduled_workflow';

package/dist/dashboard/build-operations.js

@@ -216,6 +216,7 @@ export function buildOperationsSnapshot(input) {
             tags: asStringArray(job.tags),
             category: typeof job.category === 'string' && job.category.trim() ? job.category.trim() : undefined,
             predictable: typeof job.predictable === 'boolean' ? job.predictable : undefined,
+            lean: typeof job.lean === 'boolean' ? job.lean : undefined,
         };
     }).sort((a, b) => a.owner.localeCompare(b.owner) || a.displayName.localeCompare(b.displayName));
     const scheduledWorkflows = input.workflowSummaries

package/package.json

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