clementine-agent 1.18.119 → 1.18.121

package/dist/agent/run-agent-cron.d.ts

@@ -70,6 +70,7 @@ export interface SkillContextResult {
  */
 export declare function buildSkillContext(jobName: string, jobPrompt: string, agentSlug: string | undefined, pinnedSkills: string[] | undefined, memoryStore?: MemoryStore | null, opts?: {
     skipAutoMatch?: boolean;
+    projectWorkDir?: string;
 }): Promise<SkillContextResult>;
 /** Minimal interface for the post-task reflection + skill extraction
  *  hooks. Lets `runAgentCron` stay decoupled from the full
@@ -128,6 +129,11 @@ export interface RunAgentCronOptions {
      *  prior progress. The fix for fire-time memory drift. Undefined =
      *  legacy behavior (inject everything). */
     predictable?: boolean;
+    /** Extra read+execute scope for the agent's Read/Bash/Glob tools. Maps
+     *  directly to the CronJobDefinition.addDirs YAML field. Combined with
+     *  every pinned-skill folder so `Bash python3 scripts/render.py` works
+     *  from inside a skill bundle without the cwd being set there. */
+    addDirs?: string[];
 }
 export interface RunAgentCronResult extends RunAgentResult {
     /** The final prompt that was sent to the agent (after context injection).
@@ -184,6 +190,12 @@ export interface CronExecutionPlan {
      *  MEMORY.md / team / delegation / auto-skills were intentionally
      *  skipped. Used by the Preview verdict line. */
     predictable: boolean;
+    /** Merged list of extra directories the SDK should expose to the agent's
+     *  Read/Bash/Glob tools. Combines `opts.addDirs` with every pinned-skill
+     *  folder so a skill's `scripts/render.py` is reachable without the cwd
+     *  being set inside the skill folder. Deduped + filtered to existing
+     *  paths. Empty when the trick has no addDirs and no folder-form pins. */
+    additionalDirectories: string[];
 }
 /**
  * Plan a cron run — assemble all context, resolve skills, intersect tool/MCP

package/dist/agent/run-agent-cron.js

@@ -245,14 +245,42 @@ export async function buildSkillContext(jobName, jobPrompt, agentSlug, pinnedSki
             : (suppressedNamesRaw ?? undefined);
         const prepared = [];
         const seen = new Set();
-        // 1. Load pinned skills first via exact slug lookup.
+        // 1. Load pinned skills first via exact slug lookup. When the cron has
+        //    a workDir set, we ALSO check for a project-scoped skill at
+        //    <workDir>/.clementine/skills/<name>/SKILL.md before falling back
+        //    to the global lookup. This closes the SDK-alignment gap from the
+        //    1.18.121 audit (project skills were silently unreachable from the
+        //    cron runtime even though skill-store.getSkill supported them).
         if (pinnedSkills?.length) {
+            const projectGetSkill = opts?.projectWorkDir
+                ? (await import('./skill-store.js')).getSkill
+                : null;
             for (const pinName of pinnedSkills) {
                 if (seen.has(pinName))
                     continue;
                 if (prepared.length >= MAX_INJECTED_SKILLS)
                     break;
-                const skill = loadSkillByName(pinName, agentSlug, { suppressedNames });
+                // Project-scoped first when a workDir is in scope. The skill-store
+                // shape differs from the runtime's SkillMatch — adapt it here so
+                // the rest of the pipeline doesn't care which loader returned it.
+                let skill = null;
+                if (projectGetSkill && opts?.projectWorkDir) {
+                    const ps = projectGetSkill(pinName, { projectWorkDir: opts.projectWorkDir });
+                    if (ps && ps.scope === 'project') {
+                        const ext = (ps.frontmatter.clementine ?? {});
+                        const tools = ext.tools?.allow ?? [];
+                        skill = {
+                            name: ps.frontmatter.name,
+                            title: String(ps.frontmatter.title ?? ps.frontmatter.name),
+                            content: ps.body,
+                            toolsUsed: Array.isArray(tools) ? tools.map(String) : [],
+                            attachments: [],
+                            skillDir: path.dirname(path.dirname(ps.filePath)),
+                        };
+                    }
+                }
+                if (!skill)
+                    skill = loadSkillByName(pinName, agentSlug, { suppressedNames });
                 if (!skill) {
                     missing.push(pinName);
                     logger.warn({ jobName, pin: pinName, agentSlug }, 'cron: pinned skill not found');
@@ -403,7 +431,7 @@ export async function buildCronExecutionPlan(opts) {
     const delegationContext = predictable ? '' : buildDelegationContext(agentSlug);
     const teamContext = predictable ? '' : buildTeamContext(agentSlug);
     const criteriaContext = buildCriteriaContext(opts.successCriteria);
-    const skillResult = await buildSkillContext(opts.jobName, opts.jobPrompt, agentSlug, opts.pinnedSkills, opts.memoryStore, { skipAutoMatch: predictable });
+    const skillResult = await buildSkillContext(opts.jobName, opts.jobPrompt, agentSlug, opts.pinnedSkills, opts.memoryStore, { skipAutoMatch: predictable, projectWorkDir: opts.workDir });
     const skillContext = skillResult.text;
     const howToRespond = `## How to respond\n` +
         `You're sending this directly to ${ownerName} as a DM. ` +
@@ -448,6 +476,46 @@ export async function buildCronExecutionPlan(opts) {
     const configuredCap = tier >= 2 ? BUDGET.cronT2 : BUDGET.cronT1;
     const maxBudget = opts.maxBudgetUsd ?? (configuredCap > 0 ? configuredCap : undefined);
     const effort = tier >= 2 ? 'high' : 'medium';
+    // 1.18.121 — assemble additionalDirectories. Combines:
+    //   1. opts.addDirs (from CronJobDefinition.addDirs YAML field)
+    //   2. Every pinned-skill folder so the skill's scripts/ + reference docs
+    //      are reachable via Read/Bash without the cwd being set inside the
+    //      skill folder.
+    // Deduped via Set; filtered to paths that actually exist on disk so we
+    // don't trigger SDK errors on stale references.
+    const dirSet = new Set();
+    for (const d of opts.addDirs ?? []) {
+        if (d && typeof d === 'string')
+            dirSet.add(d);
+    }
+    for (const applied of skillResult.applied) {
+        // skillResult.applied lacks the on-disk path; pull it from the prepared
+        // skill list (which we have in scope as a closure via the skillContext
+        // builder). Cheaper to reconstruct: every pinned-form skill lives at
+        // `<skillsRoot>/<name>/SKILL.md` and we want to expose `<skillsRoot>/<name>/`.
+        // Walk both global + agent-scoped roots; first hit wins.
+        const candidates = [
+            path.join(VAULT_DIR, '00-System', 'skills', applied.name),
+        ];
+        if (agentSlug) {
+            candidates.unshift(path.join(VAULT_DIR, '00-System', 'agents', agentSlug, 'skills', applied.name));
+        }
+        for (const candidate of candidates) {
+            if (fs.existsSync(path.join(candidate, 'SKILL.md'))) {
+                dirSet.add(candidate);
+                break;
+            }
+        }
+    }
+    // Final filter: only emit dirs that exist (the SDK errors on missing).
+    const additionalDirectories = [...dirSet].filter(d => {
+        try {
+            return fs.statSync(d).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
     return {
         builtPrompt,
         contextBlocks: {
@@ -468,6 +536,7 @@ export async function buildCronExecutionPlan(opts) {
         agentSlug,
         ownerName,
         predictable,
+        additionalDirectories,
     };
 }
 /**
@@ -483,7 +552,7 @@ export async function buildCronExecutionPlan(opts) {
  */
 export async function runAgentCron(opts) {
     const plan = await buildCronExecutionPlan(opts);
-    const { builtPrompt, agentSlug, effort, maxBudgetUsd: maxBudget, effectiveAllowedTools, mcpServerMap, composioConnected, externalConnected, mcpServersApplied, } = plan;
+    const { builtPrompt, agentSlug, effort, maxBudgetUsd: maxBudget, effectiveAllowedTools, mcpServerMap, composioConnected, externalConnected, mcpServersApplied, additionalDirectories, } = plan;
     logger.info({
         job: opts.jobName,
         tier: plan.tier,
@@ -511,6 +580,10 @@ export async function runAgentCron(opts) {
         abortSignal: opts.abortSignal,
         ...(effectiveAllowedTools ? { allowedTools: effectiveAllowedTools } : {}),
         extraMcpServers: mcpServerMap,
+        // 1.18.121 — pipe the merged addDirs+pinned-skill folders to the SDK
+        // so a skill's bundled scripts/templates are reachable via Bash/Read
+        // without making the cwd the skill folder.
+        ...(additionalDirectories.length > 0 ? { additionalDirectories } : {}),
     });
     // Mirror the run into transcripts so future chat recall can see it.
     // Legacy runCronJob did this with role='cron'; canonical needs the

package/dist/agent/run-agent.d.ts

@@ -81,6 +81,13 @@ export interface RunAgentOptions {
     allowedTools?: string[];
     /** Optional CLAUDE.md / project setting source. Defaults to ['project']. */
     settingSources?: ('project' | 'user' | 'local')[];
+    /** Extra directories the SDK should make available to the agent's tools
+     *  (Read/Bash/Glob/Grep) beyond `cwd`. Maps directly to the SDK's
+     *  `additionalDirectories` option. The cron runtime uses this to surface
+     *  pinned-skill folders so the agent can `Bash python3 scripts/render.py`
+     *  inside a skill bundle without the cwd being set to that folder.
+     *  Captured in CronJobDefinition.addDirs and piped through buildPrompt. */
+    additionalDirectories?: string[];
     /** Additional MCP servers to merge with the always-on clementine-tools
      *  server. Use to wire Composio + claude.ai integrations on chat-path
      *  invocations that need Outlook/Salesforce/etc. */

package/dist/agent/run-agent.js

@@ -299,6 +299,14 @@ export async function runAgent(prompt, opts) {
         ...(opts.model ? { model: opts.model } : {}),
         ...(opts.resumeSessionId ? { resume: opts.resumeSessionId } : {}),
         ...(sdkAbortController ? { abortController: sdkAbortController } : {}),
+        // 1.18.121 — pipe additionalDirectories through to the SDK so agents
+        // can Read / Bash inside pinned-skill folders, project-scoped skills,
+        // and any cron's add_dirs scope without their cwd being set to those
+        // folders. Was captured in CronJobDefinition.addDirs since 1.18.77 but
+        // never reached the SDK call site — this closes that gap.
+        ...(opts.additionalDirectories && opts.additionalDirectories.length > 0
+            ? { additionalDirectories: opts.additionalDirectories }
+            : {}),
     };
     const sdkOptions = normalizeClaudeSdkOptionsForOneMillionContext(sdkOptionsRaw);
     logger.info({

package/dist/agent/skill-extractor.d.ts

@@ -79,15 +79,6 @@ export declare function loadSkillByName(name: string, agentSlug?: string, opts?:
  *  `clementine.useCount` (Anthropic-canonical frontmatter keeps top-level
  *  reserved for `name`/`description`). */
 export declare function recordSkillUse(skillName: string, agentSlug?: string): void;
-/** List all active skills (global + all agent-scoped). */
-export declare function listSkills(agentSlug?: string): Array<{
-    name: string;
-    title: string;
-    source: string;
-    useCount: number;
-    updatedAt: string;
-    agentSlug?: string;
-}>;
 /**
  * Move skills that were never used (useCount=0, no usage telemetry rows) and
  * are older than `olderThanDays` to the `.archive/` subdirectory inside their

package/dist/agent/skill-extractor.js

@@ -667,36 +667,6 @@ export function recordSkillUse(skillName, agentSlug) {
     }
     catch { /* non-fatal */ }
 }
-/** List all active skills (global + all agent-scoped). */
-export function listSkills(agentSlug) {
-    const results = [];
-    const dirs = [];
-    if (agentSlug) {
-        dirs.push({ dir: agentSkillsDir(agentSlug), slug: agentSlug });
-    }
-    else {
-        dirs.push({ dir: GLOBAL_SKILLS_DIR });
-    }
-    for (const { dir, slug } of dirs) {
-        if (!existsSync(dir))
-            continue;
-        for (const f of readdirSync(dir).filter(f => f.endsWith('.md'))) {
-            try {
-                const parsed = matter(readFileSync(path.join(dir, f), 'utf-8'));
-                results.push({
-                    name: f.replace('.md', ''),
-                    title: parsed.data.title ?? f,
-                    source: parsed.data.source ?? 'unknown',
-                    useCount: parsed.data.useCount ?? 0,
-                    updatedAt: parsed.data.updatedAt ?? '',
-                    agentSlug: slug,
-                });
-            }
-            catch { /* skip */ }
-        }
-    }
-    return results;
-}
 // ── Stale skill archival ────────────────────────────────────────────
 /**
  * Move skills that were never used (useCount=0, no usage telemetry rows) and

package/dist/agent/skill-store.d.ts

@@ -77,10 +77,5 @@ export declare function migrateAllLegacySkills(): {
     migrated: MigrationResult[];
     skipped: MigrationResult[];
 };
-/** Diagnostics for the dashboard — expose where the loader looked. */
-export declare function _skillDirsForDiagnostics(workDir?: string): {
-    global: string;
-    project: string | null;
-};
 export {};
 //# sourceMappingURL=skill-store.d.ts.map

package/dist/agent/skill-store.js

@@ -647,8 +647,4 @@ export function migrateAllLegacySkills() {
     }
     return { migrated, skipped };
 }
-/** Diagnostics for the dashboard — expose where the loader looked. */
-export function _skillDirsForDiagnostics(workDir) {
-    return { global: globalSkillsDir(), project: projectSkillsDir(workDir) ?? null };
-}
 //# sourceMappingURL=skill-store.js.map

package/dist/cli/dashboard.js

@@ -32709,7 +32709,7 @@ async function deleteSkillFromStudio(name) {
     await apiDelete('/api/skills/' + encodeURIComponent(name));
     toast('Skill deleted', 'success');
     refreshBuilderSkills();
-    refreshSkills(); // also refresh the automations tab list
+    refreshSkillsPage(); // also refresh the automations tab list
   } catch(e) { toast('Error: ' + e, 'error'); }
 }
 
@@ -33093,7 +33093,7 @@ async function saveBuilderArtifact() {
       msgs.innerHTML += '<div style="text-align:center;padding:12px;color:var(--green);font-size:13px;font-weight:600">\\u2714 ' + esc(r.message || 'Saved') + '</div>';
       msgs.scrollTop = msgs.scrollHeight;
       document.getElementById('builder-save-btn').style.display = 'none';
-      if (type === 'skill') { refreshSkills(); refreshBuilderSkills(); }
+      if (type === 'skill') { refreshSkillsPage(); refreshBuilderSkills(); }
       if (type === 'cron') refreshCron();
       if (type === 'agent') refreshTeamNav();
       if (type === 'workflow') refreshWorkflows();
@@ -37299,7 +37299,7 @@ async function saveSkill() {
       document.getElementById('skill-description').value = '';
       document.getElementById('skill-triggers').value = '';
       document.getElementById('skill-steps').value = '';
-      refreshSkills();
+      refreshSkillsPage();
     } else {
       toast('Failed: ' + (r.error || 'unknown'), 'error');
     }
@@ -37311,7 +37311,7 @@ async function deleteSkill(name) {
   try {
     await apiDelete('/api/skills/' + encodeURIComponent(name));
     toast('Skill deleted', 'success');
-    refreshSkills();
+    refreshSkillsPage();
   } catch(e) { toast('Error: ' + e, 'error'); }
 }
 
@@ -37643,152 +37643,8 @@ async function refreshBrokenJobs() {
   }
 }
 
-async function refreshPendingSkills() {
-  try {
-    var r = await apiFetch('/api/skills/pending');
-    var d = await r.json();
-    var pending = d.skills || [];
-    var tabBadge = document.getElementById('tab-pending-skill-count');
-    if (tabBadge) {
-      tabBadge.textContent = String(pending.length);
-      tabBadge.style.display = pending.length > 0 ? '' : 'none';
-    }
-    var card = document.getElementById('pending-skills-card');
-    var countBadge = document.getElementById('pending-skills-count-badge');
-    var container = document.getElementById('panel-pending-skills');
-    if (!container) return;
-    if (pending.length === 0) {
-      if (card) card.style.display = 'none';
-      container.innerHTML = '';
-      return;
-    }
-    if (card) card.style.display = '';
-    if (countBadge) countBadge.textContent = pending.length + ' pending';
 
-    var html = '<div style="display:flex;flex-direction:column;gap:10px">';
-    for (var s of pending) {
-      var sourceTag = s.source === 'cron' ? '<span class="badge badge-green" style="font-size:10px">cron</span>'
-        : s.source === 'unleashed' ? '<span class="badge badge-purple" style="font-size:10px">unleashed</span>'
-        : s.source === 'chat' ? '<span class="badge badge-blue" style="font-size:10px">chat</span>'
-        : '<span class="badge badge-gray" style="font-size:10px">' + esc(s.source || 'unknown') + '</span>';
-      var age = s.createdAt ? timeAgo(s.createdAt) : '';
-      var scopeTag = s.agentSlug
-        ? '<span style="font-size:10px;color:var(--text-muted)">for ' + esc(s.agentSlug) + '</span>'
-        : '<span style="font-size:10px;color:var(--text-muted)">global</span>';
-      html += '<div style="padding:12px;border:1px solid var(--border);border-radius:8px;background:var(--bg-secondary)">'
-        + '<div style="display:flex;align-items:center;gap:8px;margin-bottom:6px;flex-wrap:wrap">'
-        + '<strong>' + esc(s.title) + '</strong> ' + sourceTag + ' ' + scopeTag
-        + (age ? ' <span style="font-size:10px;color:var(--text-muted)">\\u00b7 learned ' + age + '</span>' : '')
-        + '<span style="margin-left:auto;display:flex;gap:6px">'
-        + '<button onclick="approvePendingSkill(\\x27' + esc(s.name) + '\\x27)" style="background:var(--accent);border:1px solid var(--accent);border-radius:4px;padding:3px 10px;font-size:11px;color:white;cursor:pointer">Approve</button>'
-        + '<button onclick="rejectPendingSkill(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:3px 10px;font-size:11px;color:var(--red);cursor:pointer">Reject</button>'
-        + '</span>'
-        + '</div>'
-        + '<div style="font-size:12px;color:var(--text-secondary)">' + esc(s.description || '') + '</div>'
-        + '</div>';
-    }
-    html += '</div>';
-    container.innerHTML = html;
-  } catch(e) { /* non-fatal */ }
-}
-
-async function approvePendingSkill(name) {
-  try {
-    var r = await apiJson('POST', '/api/skills/pending/' + encodeURIComponent(name) + '/approve', {});
-    if (r && r.ok) {
-      toast(r.message || 'Skill approved', 'success');
-      refreshPendingSkills();
-      refreshSkills();
-    } else {
-      toast((r && r.message) || 'Failed to approve', 'error');
-    }
-  } catch(e) { toast('Failed to approve skill', 'error'); }
-}
 
-async function rejectPendingSkill(name) {
-  if (!confirm('Reject this pending skill? It will be deleted.')) return;
-  try {
-    var r = await apiJson('POST', '/api/skills/pending/' + encodeURIComponent(name) + '/reject', {});
-    if (r && r.ok) {
-      toast(r.message || 'Skill rejected', 'success');
-      refreshPendingSkills();
-    } else {
-      toast((r && r.message) || 'Failed to reject', 'error');
-    }
-  } catch(e) { toast('Failed to reject skill', 'error'); }
-}
-
-async function refreshSkills() {
-  refreshPendingSkills();
-  try {
-    var r = await apiFetch('/api/skills');
-    var d = await r.json();
-    var skills = d.skills || [];
-    var badge = document.getElementById('tab-skill-count');
-    var countBadge = document.getElementById('skill-count-badge');
-    if (badge) { badge.textContent = skills.length || ''; badge.style.display = skills.length > 0 ? '' : 'none'; }
-    if (countBadge) countBadge.textContent = skills.length + ' skill' + (skills.length !== 1 ? 's' : '');
-    var navSkillBadge = document.getElementById('nav-skill-count');
-    if (navSkillBadge) { navSkillBadge.textContent = skills.length || ''; navSkillBadge.style.display = skills.length > 0 ? '' : 'none'; }
-    var container = document.getElementById('panel-skills');
-    if (!container) return;
-    if (skills.length === 0) {
-      container.innerHTML = '<div class="empty-state">No skills learned yet. Skills are auto-extracted from successful tasks or taught manually above.</div>';
-      return;
-    }
-    var html = '<div style="display:flex;flex-direction:column;gap:12px">';
-    for (var s of skills) {
-      var sourceTag = s.source === 'manual' ? '<span class="badge badge-blue" style="font-size:10px">taught</span>'
-        : s.source === 'cron' ? '<span class="badge badge-green" style="font-size:10px">cron</span>'
-        : s.source === 'unleashed' ? '<span class="badge badge-purple" style="font-size:10px">unleashed</span>'
-        : '<span class="badge badge-gray" style="font-size:10px">' + esc(s.source) + '</span>';
-      var allTriggers = s.triggers || [];
-      var shownTriggers = allTriggers.slice(0, 5).map(function(t) { return '<code style="font-size:11px;background:var(--bg-tertiary);padding:2px 6px;border-radius:3px">' + esc(t) + '</code>'; }).join(' ');
-      var triggers = shownTriggers + (allTriggers.length > 5 ? ' <span style="font-size:11px;color:var(--text-muted)">+' + (allTriggers.length - 5) + ' more</span>' : '');
-      var age = s.updatedAt ? timeAgo(s.updatedAt) : '';
-      // Source context for auto-extracted skills
-      var sourceCtx = '';
-      if (s.sourceJob) sourceCtx += '<span style="font-size:10px;color:var(--text-muted)">from ' + esc(s.sourceJob) + '</span>';
-      if (s.createdAt && (s.source === 'cron' || s.source === 'unleashed')) {
-        sourceCtx += '<span style="font-size:10px;color:var(--text-muted)">' + (sourceCtx ? ' \\u00b7 ' : '') + 'learned ' + timeAgo(s.createdAt) + '</span>';
-      }
-      // Tools used pills
-      var toolsPills = '';
-      if (s.toolsUsed && s.toolsUsed.length > 0) {
-        var shownTools = s.toolsUsed.slice(0, 4).map(function(t) {
-          return '<span style="font-size:10px;background:var(--accent)15;color:var(--accent);padding:1px 6px;border-radius:3px;border:1px solid var(--accent)30">' + esc(t) + '</span>';
-        }).join(' ');
-        toolsPills = '<div style="display:flex;gap:3px;flex-wrap:wrap;margin-top:4px">'
-          + shownTools
-          + (s.toolsUsed.length > 4 ? ' <span style="font-size:10px;color:var(--text-muted)">+' + (s.toolsUsed.length - 4) + '</span>' : '')
-          + '</div>';
-      }
-      var retrieval7d = (typeof s.retrievals7d === 'number' && s.retrievals7d > 0)
-        ? ' \\u00b7 ' + s.retrievals7d + ' retrievals (7d)'
-        : '';
-      html += '<div id="skill-card-' + esc(s.name) + '" style="padding:12px;border:1px solid var(--border);border-radius:8px;background:var(--bg-secondary)">'
-        + '<div style="display:flex;align-items:center;gap:8px;margin-bottom:6px">'
-        + '<strong style="cursor:pointer" onclick="expandSkill(\\x27' + esc(s.name) + '\\x27)">' + esc(s.title) + '</strong> ' + sourceTag
-        + (sourceCtx ? ' ' + sourceCtx : '')
-        + '<span style="margin-left:auto;display:flex;align-items:center;gap:8px">'
-        + '<span style="font-size:11px;color:var(--text-muted)">used ' + s.useCount + 'x' + (age ? ' \\u00b7 ' + age : '') + retrieval7d + '</span>'
-        + '<button onclick="expandSkill(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:11px;color:var(--text-secondary);cursor:pointer">View</button>'
-        + '<button onclick="editSkillInBuilder(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:11px;color:var(--accent);cursor:pointer">Edit</button>'
-        + '<button onclick="deleteSkill(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:11px;color:var(--red);cursor:pointer">Delete</button>'
-        + '</span>'
-        + '</div>'
-        + '<div style="font-size:12px;color:var(--text-secondary);margin-bottom:4px">' + esc(s.description) + '</div>'
-        + (triggers ? '<div style="display:flex;gap:4px;flex-wrap:wrap">' + triggers + '</div>' : '')
-        + toolsPills
-        + '</div>';
-    }
-    html += '</div>';
-    container.innerHTML = html;
-  } catch(e) {
-    var c = document.getElementById('panel-skills');
-    if (c) c.innerHTML = '<div class="empty-state" style="color:var(--red)">Failed to load skills</div>';
-  }
-}
 
 // ── Agent-scoped Skills (Training tab) ──
 function toggleAgentTeachSkill() {

package/dist/cli/index.js

@@ -2728,27 +2728,47 @@ skillsCmd
     const RESET = '\x1b[0m';
     try {
         process.env.CLEMENTINE_HOME = BASE_DIR;
-        const { listSkills } = await import('../agent/skill-extractor.js');
-        const skills = listSkills(opts.agent);
+        // 1.18.121 — switched from skill-extractor (flat-only loader, broken
+        // since the 1.18.110 folder-form migration so this command was hiding
+        // every migrated skill) to skill-store, which walks both layouts and
+        // reads the canonical Anthropic frontmatter.
+        const { listSkills } = await import('../agent/skill-store.js');
+        const skills = listSkills();
+        if (opts.agent) {
+            console.error(`  ${DIM}Note: --agent filter is informational only since the 1.19 catalog. Showing all skills.${RESET}`);
+        }
         if (opts.json) {
-            console.log(JSON.stringify(skills, null, 2));
+            console.log(JSON.stringify(skills.map(s => ({
+                name: s.frontmatter.name,
+                title: s.frontmatter.title ?? s.frontmatter.name,
+                description: s.frontmatter.description ?? '',
+                layout: s.layout,
+                schemaVersion: s.schemaVersion,
+                scope: s.scope,
+                useCount: (s.frontmatter.clementine?.useCount ?? s.frontmatter.useCount ?? 0),
+                updatedAt: (s.frontmatter.clementine?.updatedAt ?? ''),
+                filePath: s.filePath,
+            })), null, 2));
             return;
         }
         if (skills.length === 0) {
             console.log();
-            console.log(`  ${DIM}No approved skills yet${opts.agent ? ` for "${opts.agent}"` : ''}.${RESET}`);
-            console.log(`  Skills get auto-extracted from successful cron / unleashed runs and queued for approval.`);
-            console.log(`  Pending: ${BOLD}clementine skills pending${RESET}`);
+            console.log(`  ${DIM}No skills found.${RESET}`);
+            console.log(`  Author one in chat ("Hey Clemmy, create a skill called X that…")`);
+            console.log(`  or in the dashboard's Skills page (${BOLD}clementine dashboard${RESET}).`);
             console.log();
             return;
         }
         console.log();
-        console.log(`  ${BOLD}${'NAME'.padEnd(36)}${'AGENT'.padEnd(20)}${'USES'.padEnd(8)}${'UPDATED'}${RESET}`);
+        console.log(`  ${BOLD}${'NAME'.padEnd(40)}${'LAYOUT'.padEnd(8)}${'USES'.padEnd(8)}${'UPDATED'}${RESET}`);
         console.log(`  ${DIM}${'─'.repeat(80)}${RESET}`);
         for (const s of skills) {
-            const agent = s.agentSlug ?? 'global';
-            const updated = s.updatedAt.slice(0, 10);
-            console.log(`  ${s.name.slice(0, 34).padEnd(36)}${CYAN}${agent.slice(0, 18).padEnd(20)}${RESET}${String(s.useCount).padEnd(8)}${DIM}${updated}${RESET}`);
+            const ext = s.frontmatter.clementine ?? {};
+            const useCount = ext.useCount ?? s.frontmatter.useCount ?? 0;
+            const rawUpdated = ext.updatedAt ?? '';
+            const updated = String(rawUpdated).slice(0, 10);
+            const layoutLabel = s.layout === 'folder' ? 'folder' : 'flat';
+            console.log(`  ${s.frontmatter.name.slice(0, 38).padEnd(40)}${CYAN}${layoutLabel.padEnd(8)}${RESET}${String(useCount).padEnd(8)}${DIM}${updated}${RESET}`);
         }
         console.log();
         console.log(`  ${DIM}Total: ${skills.length} skill${skills.length === 1 ? '' : 's'}.${RESET}`);

package/dist/gateway/cron-scheduler.js

@@ -1185,12 +1185,12 @@ export class CronScheduler {
                 const startedAt = new Date();
                 try {
                     // Standard cron jobs get a timeout via SDK AbortController (advisor may override)
-                    let response = await this.gateway.handleCronJob(job.name, jobPrompt, job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria, job.agentSlug, job.skills, job.allowedTools, job.allowedMcpServers, job.predictable);
+                    let response = await this.gateway.handleCronJob(job.name, jobPrompt, job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria, job.agentSlug, job.skills, job.allowedTools, job.allowedMcpServers, job.predictable, job.addDirs);
                     // alwaysDeliver: retry once if the response is empty/noise
                     if (job.alwaysDeliver && (!response || CronScheduler.isCronNoise(response))) {
                         logger.info({ job: job.name }, 'alwaysDeliver: empty/noise response — retrying once');
                         try {
-                            const retryResponse = await this.gateway.handleCronJob(job.name, jobPrompt + '\n\nYou MUST produce a brief status update. Do NOT return __NOTHING__.', job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria, job.agentSlug, job.skills, job.allowedTools, job.allowedMcpServers, job.predictable);
+                            const retryResponse = await this.gateway.handleCronJob(job.name, jobPrompt + '\n\nYou MUST produce a brief status update. Do NOT return __NOTHING__.', job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours, effectiveTimeoutMs, job.successCriteria, job.agentSlug, job.skills, job.allowedTools, job.allowedMcpServers, job.predictable, job.addDirs);
                             if (retryResponse && !CronScheduler.isCronNoise(retryResponse)) {
                                 response = retryResponse;
                             }

package/dist/gateway/router.d.ts

@@ -182,7 +182,11 @@ export declare class Gateway {
      *  identically. Affects only UI display + budget heuristics elsewhere. */
     _mode?: 'standard' | 'unleashed', maxHours?: number, timeoutMs?: number, successCriteria?: string[], agentSlug?: string, pinnedSkills?: string[], allowedTools?: string[], allowedMcpServers?: string[], 
     /** Predictable (contract) mode — runner skips memory/team/auto-skills. */
-    predictable?: boolean): Promise<string>;
+    predictable?: boolean, 
+    /** Extra read+exec scope for the SDK's Read/Bash/Glob tools. From the
+     *  CronJobDefinition.addDirs YAML field. Combined inside runAgentCron
+     *  with each pinned-skill folder. (1.18.121) */
+    addDirs?: string[]): Promise<string>;
     /**
      * PRD §10 / 1.18.91 — cancel an in-flight cron run by name. Returns true if
      * an AbortController was found and abort() was called, false if nothing was

package/dist/gateway/router.js

@@ -1976,7 +1976,11 @@ export class Gateway {
     // ── Trick capabilities (optional; preserve today's behavior when omitted) ─
     pinnedSkills, allowedTools, allowedMcpServers, 
     /** Predictable (contract) mode — runner skips memory/team/auto-skills. */
-    predictable) {
+    predictable, 
+    /** Extra read+exec scope for the SDK's Read/Bash/Glob tools. From the
+     *  CronJobDefinition.addDirs YAML field. Combined inside runAgentCron
+     *  with each pinned-skill folder. (1.18.121) */
+    addDirs) {
         const releaseLane = await lanes.acquire('cron');
         // Build a wall-clock abort timer from maxHours / timeoutMs.
         // Whichever is shorter wins. Defaults to 1h if neither is set.
@@ -2022,6 +2026,7 @@ export class Gateway {
                     allowedTools,
                     allowedMcpServers,
                     predictable,
+                    addDirs,
                 });
                 scanner.refreshIntegrity();
                 // Stash trick-capability metadata for the scheduler to read when

package/dist/tools/mcp-server.js

@@ -30,6 +30,7 @@ import { registerAgentHeartbeatTools } from './agent-heartbeat-tools.js';
 import { registerBackgroundTaskTools } from './background-task-tools.js';
 import { registerDecisionReflectionTools } from './decision-reflection-tools.js';
 import { registerBuilderTools } from './builder-tools.js';
+import { registerSkillTools } from './skill-tools.js';
 // ── Server ──────────────────────────────────────────────────────────────
 const serverName = (env['ASSISTANT_NAME'] ?? 'Clementine').toLowerCase() + '-tools';
 const server = new McpServer({ name: serverName, version: '1.0.0' });
@@ -73,6 +74,7 @@ registerAgentHeartbeatTools(scopedServer);
 registerBackgroundTaskTools(scopedServer);
 registerDecisionReflectionTools(scopedServer);
 registerBuilderTools(scopedServer);
+registerSkillTools(scopedServer);
 // ── Main ────────────────────────────────────────────────────────────────
 async function main() {
     // Initialize memory store and run full sync on startup

package/dist/tools/skill-tools.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Skill MCP tools (1.18.120)
+ *
+ * Lets the agent (and therefore the user, via chat in Discord / dashboard /
+ * Slack / Telegram) author and update skills in natural language.
+ *
+ * Why this matters:
+ *   - Before this, creating a skill required either editing files by hand
+ *     or clicking through the dashboard's "+ New skill" modal.
+ *   - With these tools registered, a Discord message like "Hey Clem,
+ *     create a skill called morning-deal-review that checks the deal
+ *     pipeline at 8am every weekday" can produce a real `<name>/SKILL.md`
+ *     folder on disk, ready to pin to a cron.
+ *
+ * The tools are intentionally thin wrappers around the existing skill-store
+ * write path. The Anthropic-spec validation (name regex, ≤1024-char
+ * description, body presence) is enforced by both the dashboard endpoint
+ * and these tools, so you can't smuggle a bad skill through the chat path.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerSkillTools(server: McpServer): void;
+//# sourceMappingURL=skill-tools.d.ts.map

package/dist/tools/skill-tools.js

@@ -0,0 +1,243 @@
+/**
+ * Skill MCP tools (1.18.120)
+ *
+ * Lets the agent (and therefore the user, via chat in Discord / dashboard /
+ * Slack / Telegram) author and update skills in natural language.
+ *
+ * Why this matters:
+ *   - Before this, creating a skill required either editing files by hand
+ *     or clicking through the dashboard's "+ New skill" modal.
+ *   - With these tools registered, a Discord message like "Hey Clem,
+ *     create a skill called morning-deal-review that checks the deal
+ *     pipeline at 8am every weekday" can produce a real `<name>/SKILL.md`
+ *     folder on disk, ready to pin to a cron.
+ *
+ * The tools are intentionally thin wrappers around the existing skill-store
+ * write path. The Anthropic-spec validation (name regex, ≤1024-char
+ * description, body presence) is enforced by both the dashboard endpoint
+ * and these tools, so you can't smuggle a bad skill through the chat path.
+ */
+import { writeFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import matter from 'gray-matter';
+import { VAULT_DIR, textResult, logger } from './shared.js';
+// Anthropic spec — keep these in sync with skill-store.validateSkill.
+const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const NAME_MAX_LEN = 64;
+const DESCRIPTION_MAX_LEN = 1024;
+const RESERVED_NAMES = new Set(['anthropic', 'claude']);
+function globalSkillsDir() {
+    return path.join(VAULT_DIR, '00-System', 'skills');
+}
+export function registerSkillTools(server) {
+    // ── create_skill ────────────────────────────────────────────────────
+    // Writes a folder-form skill to ~/.clementine/vault/00-System/skills/<name>/SKILL.md
+    // with Anthropic-canonical frontmatter (name + description top-level)
+    // and Clementine extensions (tools.allow, source: chat) under the
+    // `clementine` namespace.
+    server.tool('create_skill', 'Author a new reusable skill (a recipe Claude follows when invoked). Writes <name>/SKILL.md in the vault. Returns the skill name + path on success. Anthropic spec: name must match ^[a-z0-9][a-z0-9-]{0,63}$ and description ≤1024 chars.', {
+        name: z.string()
+            .describe('Skill slug — lowercase letters/digits/dashes, max 64 chars, must start with a letter or digit. Example: "morning-deal-review".'),
+        title: z.string().optional()
+            .describe('Optional friendlier display name. Example: "Morning Deal Review".'),
+        description: z.string()
+            .describe('One-paragraph summary of what this skill does and when Claude should run it. Used by the runtime auto-matcher AND surfaced as the cron task card preview when the skill is pinned. Max 1024 chars.'),
+        body: z.string()
+            .describe('The procedure body in Markdown. Use headers (# / ##), numbered lists, code fences. Max 500 lines is best practice. Example: "# Morning Deal Review\\n\\n1. Pull deals updated in the last 24h.\\n2. Surface high-value ones." '),
+        tools: z.array(z.string()).optional()
+            .describe('Optional allowlist of tool names this skill should restrict itself to (e.g. ["Read", "Bash", "memory_search"]). Stored under clementine.tools.allow. Empty/omitted means inherit the cron task or chat session defaults.'),
+        triggers: z.array(z.string()).optional()
+            .describe('Optional natural-language phrases that should auto-match this skill at runtime (e.g. ["morning deal review", "check deals today"]). Stored under clementine.triggers. Pinned skills don\'t need triggers — they fire by name.'),
+    }, async ({ name, title, description, body, tools, triggers }) => {
+        // Validate per Anthropic spec
+        if (!NAME_PATTERN.test(name)) {
+            return textResult(`❌ Name "${name}" doesn't match the spec. Use lowercase letters, digits, and dashes only — must start with a letter or digit, max 64 chars.`);
+        }
+        if (name.length > NAME_MAX_LEN) {
+            return textResult(`❌ Name is too long (${name.length} chars). Max is ${NAME_MAX_LEN}.`);
+        }
+        if (RESERVED_NAMES.has(name) || /\b(anthropic|claude)\b/i.test(name)) {
+            return textResult(`❌ Name "${name}" uses a reserved word ("anthropic" or "claude"). Pick another.`);
+        }
+        if (!description || !description.trim()) {
+            return textResult('❌ Description is required — Claude uses it to decide when to apply this skill.');
+        }
+        if (description.length > DESCRIPTION_MAX_LEN) {
+            return textResult(`❌ Description is too long (${description.length} chars). Max is ${DESCRIPTION_MAX_LEN}.`);
+        }
+        if (!body || !body.trim()) {
+            return textResult('❌ Procedure body is required — that\'s what Claude actually runs.');
+        }
+        const skillsDir = globalSkillsDir();
+        const folderPath = path.join(skillsDir, name);
+        const entryPath = path.join(folderPath, 'SKILL.md');
+        if (existsSync(entryPath)) {
+            return textResult(`❌ Skill "${name}" already exists at ${entryPath}. Use update_skill instead, or pick a different name.`);
+        }
+        try {
+            mkdirSync(folderPath, { recursive: true });
+            const now = new Date().toISOString();
+            const fm = { name, description };
+            if (title && title.trim())
+                fm.title = title.trim();
+            const clementineExt = {
+                source: 'chat',
+                useCount: 0,
+                createdAt: now,
+                updatedAt: now,
+                version: 1,
+            };
+            if (Array.isArray(tools) && tools.length > 0) {
+                clementineExt.tools = { allow: tools.map(String).map(s => s.trim()).filter(Boolean) };
+            }
+            if (Array.isArray(triggers) && triggers.length > 0) {
+                clementineExt.triggers = triggers.map(String).map(s => s.trim()).filter(Boolean);
+            }
+            fm.clementine = clementineExt;
+            const content = matter.stringify(body.endsWith('\n') ? body : body + '\n', fm);
+            writeFileSync(entryPath, content);
+            logger.info({ name, entryPath, source: 'chat' }, 'Skill created via chat');
+            const toolsLine = (tools && tools.length > 0) ? `\nAllowed tools: ${tools.slice(0, 5).join(', ')}${tools.length > 5 ? `, +${tools.length - 5} more` : ''}` : '';
+            const triggersLine = (triggers && triggers.length > 0) ? `\nTriggers: ${triggers.slice(0, 4).join(', ')}${triggers.length > 4 ? `, +${triggers.length - 4} more` : ''}` : '';
+            return textResult(`✅ Created skill "${name}" at ${entryPath}\n` +
+                `Description: ${description.slice(0, 200)}${description.length > 200 ? '…' : ''}` +
+                toolsLine +
+                triggersLine +
+                `\n\nThe skill is ready to pin to any task — open the cron editor, go to Tools & MCP, click "+ Add skill" and select "${name}". Or invoke it directly in chat: "Run the ${title || name} skill."`);
+        }
+        catch (err) {
+            logger.error({ err, name }, 'create_skill failed');
+            return textResult(`❌ Failed to write the skill: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // ── update_skill ────────────────────────────────────────────────────
+    // Edits an existing skill. Preserves frontmatter the caller doesn't
+    // touch (useCount, lastUsed, migration provenance, custom fields) so
+    // chat edits don't reset the lifecycle metadata.
+    server.tool('update_skill', 'Update an existing skill\'s description, body, tools, or triggers. Preserves lifecycle metadata (useCount, createdAt, etc.). Returns the updated path on success.', {
+        name: z.string().describe('Slug of the skill to update (e.g. "morning-deal-review").'),
+        description: z.string().optional().describe('New description (one paragraph, ≤1024 chars).'),
+        body: z.string().optional().describe('New procedure body (Markdown). Replaces the existing body in full.'),
+        tools: z.array(z.string()).optional().describe('New allowlist for clementine.tools.allow. Pass [] to clear.'),
+        triggers: z.array(z.string()).optional().describe('New trigger phrase list for clementine.triggers. Pass [] to clear.'),
+    }, async ({ name, description, body, tools, triggers }) => {
+        if (!NAME_PATTERN.test(name)) {
+            return textResult(`❌ Name "${name}" is not a valid skill slug.`);
+        }
+        const skillsDir = globalSkillsDir();
+        const folderEntry = path.join(skillsDir, name, 'SKILL.md');
+        const flatEntry = path.join(skillsDir, name + '.md');
+        const targetPath = existsSync(folderEntry) ? folderEntry : (existsSync(flatEntry) ? flatEntry : null);
+        if (!targetPath) {
+            return textResult(`❌ Skill "${name}" not found. Use create_skill if you want to author it from scratch.`);
+        }
+        try {
+            const raw = readFileSync(targetPath, 'utf-8');
+            const parsed = matter(raw);
+            const fm = { ...parsed.data };
+            fm.name = name;
+            if (description !== undefined) {
+                if (description.length > DESCRIPTION_MAX_LEN) {
+                    return textResult(`❌ Description is too long (${description.length} chars). Max is ${DESCRIPTION_MAX_LEN}.`);
+                }
+                fm.description = description;
+            }
+            const ext = (fm.clementine && typeof fm.clementine === 'object') ? fm.clementine : {};
+            ext.updatedAt = new Date().toISOString();
+            if (tools !== undefined) {
+                if (tools.length > 0)
+                    ext.tools = { ...(ext.tools || {}), allow: tools };
+                else if (ext.tools && typeof ext.tools === 'object')
+                    delete ext.tools.allow;
+            }
+            if (triggers !== undefined) {
+                if (triggers.length > 0)
+                    ext.triggers = triggers;
+                else
+                    delete ext.triggers;
+            }
+            fm.clementine = ext;
+            const newBody = body !== undefined ? (body.endsWith('\n') ? body : body + '\n') : parsed.content;
+            const content = matter.stringify(newBody, fm);
+            writeFileSync(targetPath, content);
+            logger.info({ name, targetPath, source: 'chat' }, 'Skill updated via chat');
+            const changed = [];
+            if (description !== undefined)
+                changed.push('description');
+            if (body !== undefined)
+                changed.push('body');
+            if (tools !== undefined)
+                changed.push('tools');
+            if (triggers !== undefined)
+                changed.push('triggers');
+            return textResult(`✅ Updated skill "${name}" — changed: ${changed.join(', ') || '(no fields specified)'}.\n` +
+                `Path: ${targetPath}`);
+        }
+        catch (err) {
+            logger.error({ err, name }, 'update_skill failed');
+            return textResult(`❌ Failed to update the skill: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+    // ── list_skills ─────────────────────────────────────────────────────
+    // Read-only — lets the agent answer "what skills do I have?" in chat
+    // without needing to fall back to file-system tools.
+    server.tool('list_skills', 'List every skill currently in the global vault. Returns name, title, description, schema version (anthropic / clementine / legacy), and layout (folder / flat). Useful when the user asks "what skills do you have?" or "show me my skills."', {}, async () => {
+        try {
+            const skillsDir = globalSkillsDir();
+            if (!existsSync(skillsDir))
+                return textResult('No skills directory yet. Use create_skill to author your first one.');
+            const { readdirSync, statSync } = await import('node:fs');
+            const items = readdirSync(skillsDir);
+            const skills = [];
+            for (const item of items) {
+                if (item.startsWith('.'))
+                    continue;
+                const full = path.join(skillsDir, item);
+                let st;
+                try {
+                    st = statSync(full);
+                }
+                catch {
+                    continue;
+                }
+                if (st.isDirectory()) {
+                    const entry = path.join(full, 'SKILL.md');
+                    if (!existsSync(entry))
+                        continue;
+                    try {
+                        const fm = matter(readFileSync(entry, 'utf-8')).data;
+                        skills.push({
+                            name: String(fm.name ?? item),
+                            title: String(fm.title ?? fm.name ?? item),
+                            description: String(fm.description ?? ''),
+                            layout: 'folder',
+                        });
+                    }
+                    catch { /* skip malformed */ }
+                }
+                else if (st.isFile() && item.endsWith('.md') && !item.endsWith('.bak.md')) {
+                    try {
+                        const fm = matter(readFileSync(full, 'utf-8')).data;
+                        skills.push({
+                            name: String(fm.name ?? item.replace(/\.md$/, '')),
+                            title: String(fm.title ?? fm.name ?? item),
+                            description: String(fm.description ?? ''),
+                            layout: 'flat',
+                        });
+                    }
+                    catch { /* skip malformed */ }
+                }
+            }
+            if (skills.length === 0)
+                return textResult('No skills found yet. Use create_skill to author your first one.');
+            skills.sort((a, b) => a.name.localeCompare(b.name));
+            const lines = skills.map(s => `• ${s.title} (\`${s.name}\`) — ${s.description.slice(0, 120)}${s.description.length > 120 ? '…' : ''}`);
+            return textResult(`${skills.length} skill${skills.length === 1 ? '' : 's'}:\n\n${lines.join('\n')}`);
+        }
+        catch (err) {
+            return textResult(`❌ Failed to list skills: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    });
+}
+//# sourceMappingURL=skill-tools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.119",
+  "version": "1.18.121",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",
@@ -53,7 +53,6 @@
     "node-cron": "^3.0.3",
     "pdf-parse": "^1.1.1",
     "pino": "^9.6.0",
-    "twilio": "^5.5.0",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },