clementine-agent 1.18.131 → 1.18.133

package/dist/channels/discord.js

@@ -34,6 +34,14 @@ const slashCommands = [
         .addChoices({ name: 'List jobs', value: 'list' }, { name: 'Run a job', value: 'run' }, { name: 'Enable a job', value: 'enable' }, { name: 'Disable a job', value: 'disable' }))
         .addStringOption(o => o.setName('job').setDescription('Job name (for run/enable/disable)').setAutocomplete(true)),
     new SlashCommandBuilder().setName('heartbeat').setDescription('Run heartbeat check manually'),
+    // 1.18.132 — Phase 3: /skill is the on-demand sibling to scheduled
+    // skills. List the catalog or fire any skill once from anywhere
+    // Discord can reach. Uses cmdCronRun's catalog fallback (1.18.129)
+    // so unscheduled skills work too.
+    new SlashCommandBuilder().setName('skill').setDescription('List or run a skill on demand')
+        .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
+        .addChoices({ name: 'List skills', value: 'list' }, { name: 'Run a skill', value: 'run' }))
+        .addStringOption(o => o.setName('name').setDescription('Skill name (for run)').setAutocomplete(true)),
     new SlashCommandBuilder().setName('tools').setDescription('List available MCP tools'),
     new SlashCommandBuilder().setName('toolset').setDescription('Set this chat tool mode')
         .addStringOption(o => o.setName('mode').setDescription('Tool mode').setRequired(true)
@@ -1190,6 +1198,23 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                         .slice(0, 25);
                     await interaction.respond(filtered.map(name => ({ name, value: name })));
                 }
+                else if (interaction.commandName === 'skill') {
+                    // 1.18.132 — autocomplete from the live skill catalog (every
+                    // skill, scheduled or not). cmdCronRun handles either case.
+                    const focused = interaction.options.getFocused().toLowerCase();
+                    try {
+                        const { listSkills } = await import('../agent/skill-store.js');
+                        const skills = listSkills();
+                        const filtered = skills
+                            .map(s => s.frontmatter.name)
+                            .filter(name => name.toLowerCase().includes(focused))
+                            .slice(0, 25);
+                        await interaction.respond(filtered.map(name => ({ name, value: name })));
+                    }
+                    catch {
+                        await interaction.respond([]);
+                    }
+                }
                 return;
             }
             // ── Slash commands ───────────────────────────────────────────────
@@ -1373,6 +1398,76 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
                     gateway.injectContext(sessionKey, `!cron run ${jobName}`, response);
                     return;
                 }
+                // 1.18.132 — Phase 3: /skill list / /skill run <name>
+                // List shows the full catalog (folder + flat) with descriptions.
+                // Run fires the named skill via the same cronScheduler.runManual
+                // path; cmdCronRun's catalog fallback (1.18.129) means unscheduled
+                // skills still fire correctly. Output streams back to Discord.
+                if (name === 'skill') {
+                    const action = cmd.options.getString('action', true);
+                    const skillName = cmd.options.getString('name') ?? '';
+                    if (action === 'list') {
+                        try {
+                            const { listSkills } = await import('../agent/skill-store.js');
+                            const skills = listSkills();
+                            if (skills.length === 0) {
+                                await cmd.reply('No skills found yet. Use the dashboard Skill Builder or `mcp__clementine-tools__create_skill` to author one.');
+                                return;
+                            }
+                            const lines = skills.map(s => {
+                                const fm = s.frontmatter;
+                                const ext = fm.clementine ?? {};
+                                const useCount = typeof ext.useCount === 'number' ? ext.useCount : 0;
+                                const desc = (fm.description || '').slice(0, 100) + ((fm.description || '').length > 100 ? '…' : '');
+                                return `• \`${fm.name}\` — ${desc}${useCount > 0 ? ` (${useCount}×)` : ''}`;
+                            });
+                            const header = `**${skills.length} skill${skills.length === 1 ? '' : 's'} available** — fire any with \`/skill run <name>\`:\n\n`;
+                            const chunks = chunkText(header + lines.join('\n'), 1900);
+                            await cmd.reply(chunks[0]);
+                            for (let i = 1; i < chunks.length; i++)
+                                await cmd.followUp(chunks[i]);
+                        }
+                        catch (err) {
+                            await cmd.reply(`Failed to list skills: ${err}`);
+                        }
+                        return;
+                    }
+                    if (action === 'run') {
+                        if (!skillName) {
+                            await cmd.reply('Specify a skill name. Try `/skill list` to see options.');
+                            return;
+                        }
+                        try {
+                            const { getSkill } = await import('../agent/skill-store.js');
+                            const skill = getSkill(skillName);
+                            if (!skill) {
+                                await cmd.reply(`Skill '${skillName}' not found. Try \`/skill list\`.`);
+                                return;
+                            }
+                            // Re-uses the cron run pipeline. cmdCronRun (1.18.129) falls
+                            // back to the skill catalog when the name isn't a registered
+                            // cron job, so this works for both scheduled + unscheduled
+                            // skills.
+                            if (cronScheduler.isJobRunning(skillName)) {
+                                await cmd.reply(`Skill '${skillName}' is already running.`);
+                                return;
+                            }
+                            await cmd.deferReply();
+                            const response = await cronScheduler.runManual(skillName);
+                            const chunks = chunkText(response || `*(skill '${skillName}' completed — no output)*`, 1900);
+                            await cmd.editReply(chunks[0]);
+                            for (let i = 1; i < chunks.length; i++)
+                                await cmd.followUp(chunks[i]);
+                            gateway.injectContext(sessionKey, `!skill run ${skillName}`, response);
+                        }
+                        catch (err) {
+                            await cmd.followUp({ content: `Skill run failed: ${err}` }).catch(() => { });
+                        }
+                        return;
+                    }
+                    await cmd.reply('Unknown action. Try `/skill list` or `/skill run <name>`.');
+                    return;
+                }
                 // Workflow command
                 if (name === 'workflow') {
                     const action = cmd.options.getString('action', true);

package/dist/cli/dashboard.js

@@ -5066,6 +5066,189 @@ export async function cmdDashboard(opts) {
             res.status(500).json({ ok: false, error: String(err) });
         }
     });
+    // 1.18.132 — Phase 3: convert a legacy cron to a scheduled-skill
+    // registry entry. Distinct from /api/cron/:job/migrate (which keeps
+    // the cron in CRON.md but cleans it up). This endpoint REMOVES the
+    // entry from CRON.md and writes it into ~/.clementine/schedules.json
+    // — the Anthropic-pure target shape.
+    //
+    // Eligibility: the cron must already pin a skill OR have a matchable
+    // skill name. We refuse to migrate a cron with no skill to fall back
+    // on, because the schedules.json shape only references {skillName →
+    // schedule}; it has no place for the cron's own prompt body. Users
+    // with custom-prompt crons can either (a) create a skill from the
+    // prompt first via the Builder, then re-run this, or (b) keep the
+    // legacy cron format.
+    app.post('/api/cron/:job/migrate-to-skill', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job name required' });
+                return;
+            }
+            const { findMatchingSkill } = await import('../agent/cron-migrator.js');
+            const { 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` });
+            // Only migrate true legacy CRON.md jobs — scheduled skills aren't migration targets.
+            if (target.source === 'scheduled-skill') {
+                return res.status(400).json({ ok: false, error: 'already a scheduled skill' });
+            }
+            // Find the skill to bind. Prefer an explicit pin; fall back to
+            // findMatchingSkill which uses prompt + name keyword overlap.
+            let skillName = null;
+            const skills = listSkills();
+            if (target.skills && target.skills.length > 0) {
+                // Use the first pinned skill that actually exists in the catalog.
+                skillName = target.skills.find(s => skills.some(sk => sk.frontmatter.name === s)) ?? target.skills[0];
+            }
+            else {
+                const m = findMatchingSkill(target, skills);
+                if (m)
+                    skillName = m.frontmatter.name;
+            }
+            if (!skillName) {
+                return res.status(400).json({
+                    ok: false,
+                    error: 'No skill match. Create a skill from this prompt in the Builder first, then retry.',
+                });
+            }
+            // Sanity: a skill of this name must exist in the catalog (otherwise
+            // the runtime will treat it as a missing pin).
+            if (!skills.some(s => s.frontmatter.name === skillName)) {
+                return res.status(400).json({ ok: false, error: `Pinned skill "${skillName}" not in catalog. Create it first.` });
+            }
+            // Write to schedules.json. Carry over agentSlug + enabled + schedule.
+            const entry = setSchedule(skillName, {
+                schedule: target.schedule,
+                enabled: target.enabled !== false,
+                agentSlug: target.agentSlug ?? null,
+            });
+            // Remove from CRON.md by bare name.
+            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) {
+                return res.status(404).json({ ok: false, error: `job not in CRON.md (looked for "${bareJobName}")` });
+            }
+            const removed = jobs.splice(idx, 1)[0];
+            writeCronFileAt(cronFile, parsed, jobs);
+            // Hot-reload + broadcast so the Tasks page updates without manual refresh.
+            try {
+                const gw = await getGateway();
+                const sched = gw.cronScheduler;
+                if (sched && typeof sched.reloadJobs === 'function')
+                    sched.reloadJobs();
+            }
+            catch { /* best-effort */ }
+            try {
+                broadcastEvent({ type: 'cron_deleted', data: { job: jobName, source: 'cron-md', migrated: true } });
+            }
+            catch { /* non-fatal */ }
+            res.json({
+                ok: true,
+                skillName,
+                scheduleEntry: entry,
+                removedFrom: cronFile,
+                bakPath,
+                removedBareName: removed?.name,
+                message: `Converted "${jobName}" → scheduled skill "${skillName}". CRON.md backup at ${bakPath}.`,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    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 { setSchedule } = await import('../agent/schedule-registry.js');
+            const { parseCronJobs, parseAgentCronJobs } = await import('../gateway/cron-scheduler.js');
+            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 = [];
+            // 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;
+                if (job.skills && job.skills.length > 0) {
+                    skillName = job.skills.find(s => skills.some(sk => sk.frontmatter.name === s)) ?? null;
+                }
+                if (!skillName) {
+                    const m = findMatchingSkill(job, skills);
+                    if (m)
+                        skillName = m.frontmatter.name;
+                }
+                if (!skillName) {
+                    skipped.push({ name: job.name, reason: 'no skill match' });
+                    continue;
+                }
+                if (!skills.some(s => s.frontmatter.name === skillName)) {
+                    skipped.push({ name: job.name, reason: `skill "${skillName}" not in catalog` });
+                    continue;
+                }
+                try {
+                    setSchedule(skillName, {
+                        schedule: job.schedule,
+                        enabled: job.enabled !== false,
+                        agentSlug: job.agentSlug ?? null,
+                    });
+                    migrated.push({ name: job.name, skillName });
+                    const { cronFile, bareJobName } = resolveJobCronFile(job.name);
+                    if (!byFile.has(cronFile))
+                        byFile.set(cronFile, { jobsToRemove: new Set(), cronFile });
+                    byFile.get(cronFile).jobsToRemove.add(bareJobName);
+                }
+                catch (err) {
+                    skipped.push({ name: job.name, reason: String(err) });
+                }
+            }
+            const touchedFiles = [];
+            for (const { cronFile, jobsToRemove } of byFile.values()) {
+                try {
+                    const bakPath = cronFile + '.bak';
+                    try {
+                        writeFileSync(bakPath, readFileSync(cronFile, 'utf-8'));
+                    }
+                    catch { /* best-effort */ }
+                    const { parsed, jobs } = readCronFileAt(cronFile);
+                    const filtered = jobs.filter(j => !jobsToRemove.has(String(j.name)));
+                    writeCronFileAt(cronFile, parsed, filtered);
+                    touchedFiles.push(cronFile);
+                }
+                catch (err) {
+                    skipped.push({ name: '(file write)', reason: `${cronFile}: ${err}` });
+                }
+            }
+            try {
+                const gw = await getGateway();
+                const sched = gw.cronScheduler;
+                if (sched && typeof sched.reloadJobs === 'function')
+                    sched.reloadJobs();
+            }
+            catch { /* best-effort */ }
+            try {
+                broadcastEvent({ type: 'cron_migrated_to_skills', data: { migratedCount: migrated.length } });
+            }
+            catch { /* non-fatal */ }
+            res.json({ ok: true, migrated, skipped, touchedFiles });
+        }
+        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');
@@ -6864,6 +7047,57 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ error: String(err) });
         }
     });
+    // 1.18.132 — list top-level files in a registered project. Used by
+    // the Skill Builder's Files sidebar tab to surface clickable file
+    // paths that the user can insert into their skill body.
+    // Hardened: the path query param MUST match a registered project's
+    // path exactly (no path traversal, no scanning arbitrary directories).
+    app.get('/api/projects/files', (req, res) => {
+        try {
+            const projPath = String(req.query.path ?? '');
+            if (!projPath)
+                return res.status(400).json({ ok: false, error: 'path query param required' });
+            const projects = loadProjectsMeta();
+            const found = projects.find((p) => p.path === projPath);
+            if (!found)
+                return res.status(404).json({ ok: false, error: 'path is not a registered project' });
+            if (!existsSync(projPath))
+                return res.json({ ok: true, files: [], note: 'project path does not exist on disk' });
+            let entries;
+            try {
+                entries = readdirSync(projPath);
+            }
+            catch (err) {
+                return res.status(500).json({ ok: false, error: 'failed to list directory: ' + String(err) });
+            }
+            // Skip hidden + node_modules + standard noise. Up to 50 entries
+            // (the sidebar caps at 50 anyway). One level deep — the panel is
+            // an entry point; users can dig further from their editor.
+            const NOISE = new Set(['node_modules', '.git', '.DS_Store', 'dist', 'build', '.next', '.cache']);
+            const out = [];
+            for (const entry of entries.sort()) {
+                if (entry.startsWith('.'))
+                    continue;
+                if (NOISE.has(entry))
+                    continue;
+                const abs = path.join(projPath, entry);
+                let st;
+                try {
+                    st = statSync(abs);
+                }
+                catch {
+                    continue;
+                }
+                out.push({ relPath: entry, isDir: st.isDirectory(), sizeBytes: st.isFile() ? st.size : 0 });
+                if (out.length >= 50)
+                    break;
+            }
+            res.json({ ok: true, files: out });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
     // ── Available Tools ──────────────────────────────────────────
     app.get('/api/available-tools', async (_req, res) => {
         try {
@@ -25276,10 +25510,53 @@ function renderScheduledTaskCard(task) {
     + '<button class="btn-sm secondary" data-trace-job="' + esc(task.name) + '" title="View execution trace">Trace</button>'
     + (defObj.source === 'scheduled-skill'
         ? '<button class="btn-sm secondary btn-danger" onclick="unscheduleSkillFromCard(\\x27' + safeName + '\\x27)" title="Remove the schedule (skill stays)">Unschedule</button>'
-        : '<button class="btn-sm secondary btn-danger" onclick="confirmDeleteCron(\\x27' + safeName + '\\x27)" title="Delete task">Del</button>')
+        : '<button class="btn-sm secondary" onclick="migrateCronToSkillFromCard(\\x27' + safeName + '\\x27)" title="Convert this legacy cron to a scheduled skill — Anthropic-pure format">→ Skill</button>'
+          + '<button class="btn-sm secondary btn-danger" onclick="confirmDeleteCron(\\x27' + safeName + '\\x27)" title="Delete task">Del</button>')
     + '</div></div>';
 }
 
+// 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).
+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;
+  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();
+  } 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.
+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;
+  try {
+    var r = await apiFetch('/api/cron/migrate-all-to-skills', { method: 'POST' });
+    var d = await r.json();
+    if (!r.ok) { toast(d.error || 'Bulk migration failed', 'error'); return; }
+    var migrated = (d.migrated || []).length;
+    var skipped = (d.skipped || []).length;
+    var msg = 'Migrated ' + migrated + ' cron' + (migrated === 1 ? '' : 's') + ' to scheduled skills';
+    if (skipped > 0) msg += '. ' + skipped + ' skipped — see console for reasons.';
+    toast(msg, migrated > 0 ? 'success' : 'info');
+    if (skipped > 0 && d.skipped) console.warn('[migrate-all-to-skills] skipped:', d.skipped);
+    if (typeof refreshCron === 'function') refreshCron();
+  } catch (err) {
+    toast('Failed: ' + err, 'error');
+  }
+}
+
 // 1.18.129 — replace the "+ New Task" tile with a small dropdown that
 // nudges users toward the new "schedule a skill" path. Legacy cron
 // option stays for backward compat / power users with hand-rolled
@@ -26817,7 +27094,30 @@ async function refreshCron() {
     // placeholder; refreshCronCleanBanner() fetches /api/cron/migrate-preview
     // async and fills this in only when there are eligible legacy jobs.
     // The banner stays empty (zero visual noise) when the vault is clean.
-    var html = '<div id="cron-migrate-banner-host"></div>';
+    // 1.18.132 — Phase 3: soft-deprecate banner. Counts legacy crons
+    // (definition.source !== 'scheduled-skill') and surfaces a one-click
+    // bulk migrator. Dismissable; persists in localStorage so it doesn't
+    // nag on every refresh.
+    var legacyCount = 0;
+    try {
+      legacyCount = (visibleTasks || []).filter(function(t) {
+        return !(t.definition && t.definition.source === 'scheduled-skill');
+      }).length;
+    } catch (_) { /* defensive */ }
+    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">'
+        + '<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>'
+        +   '<div style="font-size:11px;color:var(--text-muted);margin-top:2px">Skills are the Anthropic-pure unit of work. Scheduled-skill format is thinner, easier to maintain, and tasks can be reused on demand.</div>'
+        + '</div>'
+        + '<button class="btn-sm btn-primary" onclick="migrateAllCronsToSkills()" style="font-size:12px;padding:6px 12px">Migrate all eligible →</button>'
+        + '<button class="btn-sm" onclick="localStorage.setItem(\\x27clem-skill-migrate-banner-dismissed\\x27,\\x271\\x27);refreshCron()" title="Hide this banner" style="font-size:12px;padding:6px 10px">Dismiss</button>'
+        + '</div>';
+    }
+    var html = bannerHtml + '<div id="cron-migrate-banner-host"></div>';
     html += '<div id="health-strip" class="health-strip"></div>';
     // 1.18.115 — collapse the cost/latency/reliability/activity mini-cards
     // into a <details> block. The Health Strip already covers what most
@@ -27929,6 +28229,7 @@ async function openSkillBuilder(skillName) {
       +     '<span id="sb-save-status" style="font-size:11px;color:var(--text-muted)"></span>'
       +   '</div>'
       +   '<div style="display:flex;align-items:center;gap:6px">'
+      +     '<button onclick="sbRunSkillTest()" id="sb-test-btn" style="font-size:12px;padding:7px 12px;border:1px solid var(--green);border-radius:6px;background:transparent;color:var(--green);cursor:pointer;font-weight:500" title="Fire this skill once and stream the result inline (toast on completion)">▶ Test run</button>'
       +     '<button onclick="sbSaveCurrent()" id="sb-save-btn" class="btn-primary" style="font-size:12px;padding:7px 14px;border:none;border-radius:6px;background:var(--accent);color:#fff;font-weight:500;cursor:pointer" disabled>Save (⌘S)</button>'
       +     '<button onclick="closeSkillBuilder()" style="font-size:12px;padding:7px 12px;border:1px solid var(--border);border-radius:6px;background:transparent;color:var(--text-primary);cursor:pointer">Close</button>'
       +   '</div>'
@@ -27954,6 +28255,8 @@ async function openSkillBuilder(skillName) {
       +   '<div style="border-left:1px solid var(--border);background:var(--bg-secondary);display:flex;flex-direction:column;min-height:0">'
       +     '<div style="padding:8px 6px 0;display:flex;gap:2px;border-bottom:1px solid var(--border)">'
       +       '<button onclick="sbSwitchTab(\\x27tools\\x27)" id="sb-tab-tools" class="sb-tab" style="flex:1;font-size:11px;padding:8px 4px;border:none;background:transparent;color:var(--text-muted);cursor:pointer;border-bottom:2px solid transparent;font-weight:500">Tools</button>'
+      +       '<button onclick="sbSwitchTab(\\x27files\\x27)" id="sb-tab-files" class="sb-tab" style="flex:1;font-size:11px;padding:8px 4px;border:none;background:transparent;color:var(--text-muted);cursor:pointer;border-bottom:2px solid transparent;font-weight:500">Files</button>'
+      +       '<button onclick="sbSwitchTab(\\x27memory\\x27)" id="sb-tab-memory" class="sb-tab" style="flex:1;font-size:11px;padding:8px 4px;border:none;background:transparent;color:var(--text-muted);cursor:pointer;border-bottom:2px solid transparent;font-weight:500">Memory</button>'
       +       '<button onclick="sbSwitchTab(\\x27skills\\x27)" id="sb-tab-skills" class="sb-tab" style="flex:1;font-size:11px;padding:8px 4px;border:none;background:transparent;color:var(--text-muted);cursor:pointer;border-bottom:2px solid transparent;font-weight:500">Skills</button>'
       +     '</div>'
       +     '<div style="padding:6px 10px;border-bottom:1px solid var(--border)">'
@@ -28140,10 +28443,10 @@ async function sbDeleteFile(relPath) {
   }
 }
 
-// ── Sidebar tabs (Tools / Skills) ────────────────────────────────────
+// ── Sidebar tabs (Tools / Files / Memory / Skills) ──────────────────
 function sbSwitchTab(tab) {
   window._sbActiveTab = tab;
-  ['tools', 'skills'].forEach(function(t) {
+  ['tools', 'files', 'memory', 'skills'].forEach(function(t) {
     var el = document.getElementById('sb-tab-' + t);
     if (el) {
       el.style.color = (t === tab) ? 'var(--accent)' : 'var(--text-muted)';
@@ -28159,6 +28462,10 @@ async function sbRenderSidebar() {
   var q = (document.getElementById('sb-sidebar-search')?.value || '').toLowerCase().trim();
   if (window._sbActiveTab === 'tools') {
     await sbRenderToolsTab(listEl, q);
+  } else if (window._sbActiveTab === 'files') {
+    await sbRenderFilesTab(listEl, q);
+  } else if (window._sbActiveTab === 'memory') {
+    await sbRenderMemoryTab(listEl, q);
   } else if (window._sbActiveTab === 'skills') {
     await sbRenderSkillsTab(listEl, q);
   }
@@ -28256,6 +28563,163 @@ async function sbRenderSkillsTab(listEl, q) {
   listEl.innerHTML = html;
 }
 
+// 1.18.132 — Files tab (Phase 2.5). Browses the user's projects.
+// Click a project to expand its file tree; click a file to insert
+// its absolute path at the cursor (so the skill body can reference
+// it via Read or Bash). Scoped to projectsData (already populated by
+// /api/projects on page load); no separate filesystem walk endpoint
+// needed in this iteration.
+async function sbRenderFilesTab(listEl, q) {
+  var projects = (typeof projectsData !== 'undefined' && Array.isArray(projectsData)) ? projectsData : [];
+  if (projects.length === 0) {
+    try {
+      var pr = await window.apiFetch('/api/projects');
+      var pd = await pr.json();
+      if (pd && Array.isArray(pd.projects)) projects = pd.projects;
+    } catch (_) { /* fall through to empty */ }
+  }
+  if (q) {
+    projects = projects.filter(function(p) {
+      return ((p.name || '') + ' ' + (p.path || '')).toLowerCase().indexOf(q) > -1;
+    });
+  }
+  if (projects.length === 0) {
+    listEl.innerHTML = '<div style="padding:18px;color:var(--text-muted);font-size:11px;text-align:center">' + (q ? 'No matches.' : 'No projects yet. Add one in Settings → Projects.') + '</div>';
+    return;
+  }
+  var html = '<div style="padding:6px 12px;font-size:10px;font-weight:600;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.04em;background:var(--bg-tertiary)">Projects (' + projects.length + ')</div>';
+  for (var i = 0; i < projects.length; i++) {
+    var p = projects[i];
+    // Click on row → insert the project path. Click on icon to load
+    // a child file list inline (lazy expand).
+    html += '<div style="border-bottom:1px solid var(--border-light)">'
+      + '<div onclick="sbInsertAtCursor(\\x27' + jsStr(p.path) + '\\x27)" style="padding:7px 12px;cursor:pointer;font-size:12px;display:flex;align-items:center;gap:6px" onmouseover="this.style.background=\\x27var(--bg-tertiary)\\x27" onmouseout="this.style.background=\\x27transparent\\x27" title="Insert this absolute path at the cursor">'
+      +   '<span>📁</span>'
+      +   '<span style="font-weight:500;color:var(--text-primary);flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' + esc(p.name || p.path.split(\'/\').pop()) + '</span>'
+      +   '<button onclick="event.stopPropagation();sbToggleProjectFiles(\\x27' + jsStr(p.path) + '\\x27, this)" title="Browse files inside this project" style="background:none;border:1px solid var(--border);color:var(--text-muted);font-size:10px;padding:1px 6px;border-radius:3px;cursor:pointer">▸</button>'
+      + '</div>'
+      + '<div id="sb-files-children-' + i + '" data-project-path="' + esc(p.path) + '" style="display:none;font-size:11px;background:var(--bg-secondary);padding:4px 0"></div>'
+      + '</div>';
+  }
+  listEl.innerHTML = html;
+}
+
+// Lazy-load the child file list for a project. Hits a tiny endpoint
+// that returns the top-level files (max 50, no recursion) so we don't
+// blow the panel on huge projects.
+async function sbToggleProjectFiles(projectPath, btn) {
+  // Find the children container next to this button
+  var children = btn.parentElement.parentElement.querySelector('[data-project-path]');
+  if (!children) return;
+  if (children.style.display !== 'none') {
+    children.style.display = 'none';
+    btn.textContent = '▸';
+    return;
+  }
+  children.style.display = '';
+  btn.textContent = '▾';
+  if (!children.dataset.loaded) {
+    children.innerHTML = '<div style="padding:8px 24px;color:var(--text-muted);font-size:10px">Loading…</div>';
+    try {
+      var r = await window.apiFetch('/api/projects/files?path=' + encodeURIComponent(projectPath));
+      var d = await r.json();
+      if (!r.ok || !Array.isArray(d.files)) {
+        children.innerHTML = '<div style="padding:8px 24px;color:var(--text-muted);font-size:10px">No files surfaced (or endpoint unavailable).</div>';
+        return;
+      }
+      var html = '';
+      for (var i = 0; i < Math.min(d.files.length, 50); i++) {
+        var f = d.files[i];
+        var icon = f.isDir ? '📁' : '📄';
+        var fullPath = projectPath + '/' + f.relPath;
+        html += '<div onclick="sbInsertAtCursor(\\x27' + jsStr(fullPath) + '\\x27)" style="padding:4px 24px;cursor:pointer;display:flex;align-items:center;gap:6px" onmouseover="this.style.background=\\x27var(--bg-tertiary)\\x27" onmouseout="this.style.background=\\x27transparent\\x27">'
+          + '<span>' + icon + '</span>'
+          + '<span style="flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;color:var(--text-secondary)">' + esc(f.relPath) + '</span>'
+          + '</div>';
+      }
+      if (d.files.length > 50) {
+        html += '<div style="padding:4px 24px;color:var(--text-muted);font-size:10px;font-style:italic">+ ' + (d.files.length - 50) + ' more (open the project in your editor for the rest)</div>';
+      }
+      children.innerHTML = html;
+      children.dataset.loaded = '1';
+    } catch (err) {
+      children.innerHTML = '<div style="padding:8px 24px;color:var(--red);font-size:10px">' + esc(String(err)) + '</div>';
+    }
+  }
+}
+
+// 1.18.132 — Memory tab (Phase 2.5). Surfaces three things the agent
+// can reach when the skill runs:
+//   1. Recent extractions (last facts the auto-extractor saved)
+//   2. Top-level MEMORY.md sections (h2 headers)
+//   3. A button to insert a memory_search call template
+// Click any item → inserts a contextual reference at the cursor so
+// the skill body can document or trigger a recall.
+async function sbRenderMemoryTab(listEl, q) {
+  var html = '';
+  // 1. Recent extractions
+  try {
+    var r = await window.apiFetch('/api/memory/writes/recent?limit=12');
+    var d = await r.json();
+    var writes = (d && Array.isArray(d.writes)) ? d.writes : (d && Array.isArray(d.entries) ? d.entries : []);
+    if (q) {
+      writes = writes.filter(function(w) {
+        return JSON.stringify(w).toLowerCase().indexOf(q) > -1;
+      });
+    }
+    if (writes.length > 0) {
+      html += '<div style="padding:6px 12px;font-size:10px;font-weight:600;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.04em;background:var(--bg-tertiary)">Recent extractions</div>';
+      for (var i = 0; i < Math.min(writes.length, 8); i++) {
+        var w = writes[i];
+        var preview = (w.content_preview || w.content || w.preview || w.text || '').slice(0, 100);
+        if (!preview) continue;
+        var insertion = 'Reference recent fact: "' + preview.replace(/"/g, '\\\\\\\\"').slice(0, 80) + '"';
+        html += '<div onclick="sbInsertAtCursor(\\x27' + jsStr(insertion) + '\\x27)" style="padding:7px 12px;cursor:pointer;font-size:12px;border-bottom:1px solid var(--border-light)" onmouseover="this.style.background=\\x27var(--bg-tertiary)\\x27" onmouseout="this.style.background=\\x27transparent\\x27">'
+          + '<div style="color:var(--text-secondary);line-height:1.4;font-size:11px">' + esc(preview) + (preview.length >= 100 ? '…' : '') + '</div>'
+          + '</div>';
+      }
+    }
+  } catch (_) { /* memory writes endpoint may not be live in early daemons */ }
+  // 2. MEMORY.md slot headers
+  try {
+    var r2 = await window.apiFetch('/api/memory/md');
+    var d2 = await r2.json();
+    var content = (d2 && d2.content) || '';
+    var lines = content.split('\\n');
+    var sections = [];
+    for (var li = 0; li < lines.length; li++) {
+      var match = lines[li].match(/^##\\s+(.+)$/);
+      if (match) sections.push(match[1].trim());
+    }
+    if (q) {
+      sections = sections.filter(function(s) { return s.toLowerCase().indexOf(q) > -1; });
+    }
+    if (sections.length > 0) {
+      html += '<div style="padding:6px 12px;font-size:10px;font-weight:600;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.04em;background:var(--bg-tertiary);margin-top:4px">MEMORY.md sections</div>';
+      for (var si = 0; si < sections.length; si++) {
+        var s = sections[si];
+        var ins = 'Refer to MEMORY.md > "' + s + '" section.';
+        html += '<div onclick="sbInsertAtCursor(\\x27' + jsStr(ins) + '\\x27)" style="padding:6px 12px;cursor:pointer;font-size:12px;display:flex;align-items:center;gap:6px;border-bottom:1px solid var(--border-light)" onmouseover="this.style.background=\\x27var(--bg-tertiary)\\x27" onmouseout="this.style.background=\\x27transparent\\x27">'
+          + '<span>📄</span>'
+          + '<span style="color:var(--text-primary)">' + esc(s) + '</span>'
+          + '</div>';
+      }
+    }
+  } catch (_) { /* defensive */ }
+  // 3. Always-available memory_search insert
+  html += '<div style="padding:6px 12px;font-size:10px;font-weight:600;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.04em;background:var(--bg-tertiary);margin-top:4px">Patterns</div>';
+  html += '<div onclick="sbInsertAtCursor(\\x27Use memory_search with query: \\\\\\\"YOUR_QUERY\\\\\\\".\\x27)" style="padding:7px 12px;cursor:pointer;font-size:12px;border-bottom:1px solid var(--border-light)" onmouseover="this.style.background=\\x27var(--bg-tertiary)\\x27" onmouseout="this.style.background=\\x27transparent\\x27">'
+    + '<span style="font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-primary)">memory_search</span>'
+    + '<span style="color:var(--text-muted);font-size:10px;margin-left:8px">Recall facts/transcripts at runtime</span>'
+    + '</div>';
+  html += '<div onclick="sbInsertAtCursor(\\x27Use memory_write to save this fact: \\\\\\\"FACT\\\\\\\" with reason \\\\\\\"WHY_IT_MATTERS\\\\\\\".\\x27)" style="padding:7px 12px;cursor:pointer;font-size:12px;border-bottom:1px solid var(--border-light)" onmouseover="this.style.background=\\x27var(--bg-tertiary)\\x27" onmouseout="this.style.background=\\x27transparent\\x27">'
+    + '<span style="font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--text-primary)">memory_write</span>'
+    + '<span style="color:var(--text-muted);font-size:10px;margin-left:8px">Persist a new fact</span>'
+    + '</div>';
+  if (!html.trim()) html = '<div style="padding:18px;color:var(--text-muted);font-size:11px;text-align:center">No memory items surfaced.</div>';
+  listEl.innerHTML = html;
+}
+
 function sbInsertAtCursor(text) {
   var ed = document.getElementById('sb-editor');
   if (!ed) return;
@@ -28269,6 +28733,38 @@ function sbInsertAtCursor(text) {
   sbOnEdit();
 }
 
+// 1.18.132 — Test runner. Fires the open skill once via the same
+// /api/cron/run/:name path that the Skills detail Run-now button
+// uses (which itself works for unscheduled skills via cmdCronRun's
+// catalog fallback). Refuses to run if the file has unsaved changes
+// (otherwise the user would be testing the saved version, not what
+// they see in the editor — confusing).
+async function sbRunSkillTest() {
+  if (window._sbState.dirty) {
+    if (!confirm('Save current changes before testing? Unsaved edits won\\x27t be in the run.')) return;
+    await sbSaveCurrent();
+    if (window._sbState.dirty) return; // save failed
+  }
+  var name = window._sbState.skillName;
+  if (!name) return;
+  var btn = document.getElementById('sb-test-btn');
+  if (btn) { btn.disabled = true; btn.textContent = '⏳ Running…'; btn.style.color = 'var(--text-muted)'; btn.style.borderColor = 'var(--border)'; }
+  try {
+    var r = await window.apiFetch('/api/cron/run/' + encodeURIComponent(name), { method: 'POST' });
+    if (r.status === 409) {
+      toast('Already running. Wait for the in-flight run to finish.', 'warn');
+      return;
+    }
+    var d = await r.json();
+    if (!r.ok) { toast(d.error || 'Run failed', 'error'); return; }
+    toast('Started "' + name + '" — output streams to chat. Close the builder to see it.', 'success');
+  } catch (err) {
+    toast('Failed: ' + err, 'error');
+  } finally {
+    if (btn) { btn.disabled = false; btn.textContent = '▶ Test run'; btn.style.color = 'var(--green)'; btn.style.borderColor = 'var(--green)'; }
+  }
+}
+
 async function _openSkillModal(opts) {
   opts = opts || {};
   var existing = null;

package/dist/gateway/heartbeat-scheduler.js

@@ -1032,12 +1032,31 @@ export class HeartbeatScheduler {
         let response = null;
         try {
             const cronCall = buildInsightCheckCronCall(prompt);
+            // 1.18.132 — fix the "Prompt is too long" loop. Insight-check is
+            // an internal Haiku classifier ("should we proactively message
+            // Nathan?") with a tightly-built prompt assembled by
+            // gatherInsightSignals + buildInsightPrompt. Without predictable
+            // mode the runtime ALSO injected MEMORY.md (8k cap) + team
+            // comms + delegation queue + auto-matched skills (up to 4 skill
+            // bodies). The user's MEMORY.md alone was ~80% of the budget;
+            // adding even one auto-matched skill body tipped it past the
+            // model's input window.
+            //
+            // Pass predictable: true + an explicit empty allowedTools list so
+            // the SDK call is just: built-in claude_code system prompt +
+            // our compact insight prompt. This is a classifier, not a working
+            // agent; nothing in MEMORY.md or skill bodies is relevant to
+            // urgency rating.
             response = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, // workDir
             'standard', // mode (display only)
             undefined, // maxHours
             undefined, // timeoutMs
             undefined, // successCriteria
-            undefined);
+            undefined, // agentSlug
+            undefined, // pinnedSkills
+            [], // allowedTools — empty = no MCP injection
+            [], // allowedMcpServers — empty = no MCP servers wired
+            true);
             this.runLog.append({
                 jobName: 'insight-check',
                 startedAt: icStartedAt.toISOString(),

package/package.json

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