clementine-agent 1.18.143 → 1.18.145

package/dist/agent/self-improve.js

@@ -17,6 +17,7 @@ import pino from 'pino';
 import { BASE_DIR, SELF_IMPROVE_DIR, SOUL_FILE, CRON_FILE, WORKFLOWS_DIR, VAULT_DIR, MEMORY_DB_PATH, AGENTS_DIR, CRON_REFLECTIONS_DIR, GOALS_DIR, } from '../config.js';
 import { listAllGoals } from '../tools/shared.js';
 import { MemoryStore } from '../memory/store.js';
+import { ANTHROPIC_SKILL_NAME_PATTERN } from './skill-store.js';
 const logger = pino({ name: 'clementine.self-improve' });
 // ── Defaults ─────────────────────────────────────────────────────────
 const DEFAULT_CONFIG = {
@@ -2196,7 +2197,7 @@ export function validateProposal(area, target, proposedChange) {
         // present + non-empty, no XML tags in description, no Anthropic-
         // reserved words in name. Reuses the centralized validator that
         // dashboard + MCP + auto-extract all share.
-        if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(target)) {
+        if (!ANTHROPIC_SKILL_NAME_PATTERN.test(target)) {
             return { valid: false, error: `skill target must be a valid slug (got "${target}")` };
         }
         let parsed;
@@ -2210,7 +2211,7 @@ export function validateProposal(area, target, proposedChange) {
         const name = typeof fm.name === 'string' ? fm.name : '';
         const description = typeof fm.description === 'string' ? fm.description : '';
         const body = parsed.content || '';
-        if (!name || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
+        if (!name || !ANTHROPIC_SKILL_NAME_PATTERN.test(name)) {
             return { valid: false, error: 'skill frontmatter "name" missing or invalid slug' };
         }
         if (name !== target) {

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

@@ -22,6 +22,12 @@
  * crons → folder-form skills.
  */
 import type { Skill, SkillScope, SkillValidationWarning, CronJobDefinition } from '../types.js';
+/**
+ * Anthropic skill slug regex. Exported (1.18.144) so other modules
+ * (self-improve, migration tooling) don't drift their own copies.
+ * Lowercase letters/digits/dashes, must start with [a-z0-9], ≤64 chars.
+ */
+export declare const ANTHROPIC_SKILL_NAME_PATTERN: RegExp;
 /** Run Anthropic-spec validations on a parsed skill. Errors are spec
  *  violations (skill would be rejected by the Anthropic API); warnings
  *  are best-practice hints (still loadable). Findings render in the

package/dist/agent/skill-store.js

@@ -37,7 +37,13 @@ function projectSkillsDir(workDir) {
     return existsSync(dir) ? dir : null;
 }
 // ── Anthropic spec validations ────────────────────────────────────────
-const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+/**
+ * Anthropic skill slug regex. Exported (1.18.144) so other modules
+ * (self-improve, migration tooling) don't drift their own copies.
+ * Lowercase letters/digits/dashes, must start with [a-z0-9], ≤64 chars.
+ */
+export const ANTHROPIC_SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const NAME_PATTERN = ANTHROPIC_SKILL_NAME_PATTERN;
 const RESERVED_NAMES = new Set(['anthropic', 'claude']);
 const NAME_MAX_LEN = 64;
 const DESCRIPTION_MAX_LEN = 1024;

package/dist/cli/routes/workflows.js

@@ -116,7 +116,8 @@ export function workflowsRouter(deps) {
             const { wf, agentSlug } = candidates[0];
             // Slugify the workflow name to the Anthropic regex
             const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64);
-            if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(slug)) {
+            const { ANTHROPIC_SKILL_NAME_PATTERN } = await import('../../agent/skill-store.js');
+            if (!ANTHROPIC_SKILL_NAME_PATTERN.test(slug)) {
                 res.status(400).json({ ok: false, error: `Workflow name "${name}" cannot be slugified to Anthropic regex` });
                 return;
             }

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

@@ -33,6 +33,22 @@
  * missing fields, drop invalid values).
  */
 export declare function loadStateFile<T>(filePath: string, defaultValue: T, validator?: (raw: unknown) => T): T;
+/**
+ * 1.18.144 — Generic JSON file reader for non-scheduler call sites.
+ *
+ * Same try/parse/fallback shape as loadStateFile but with a `silent`
+ * option for callers who expect missing files to be common (e.g. a
+ * tool reading an optional config) and don't want every miss to log.
+ *
+ * Six+ files were inlining `try { JSON.parse(readFileSync(p)) } catch
+ * { return default }` before this. They now share one well-tested
+ * helper, which means the next file that needs to read a JSON sidecar
+ * doesn't add a seventh variant.
+ */
+export declare function loadJsonFile<T>(filePath: string, defaultValue: T, opts?: {
+    silent?: boolean;
+    validator?: (raw: unknown) => T;
+}): T;
 export interface SaveStateOptions {
     /**
      * If true, write to `<file>.tmp` then rename — guarantees the on-disk

package/dist/gateway/scheduler-state.js

@@ -48,6 +48,32 @@ export function loadStateFile(filePath, defaultValue, validator) {
         return defaultValue;
     }
 }
+/**
+ * 1.18.144 — Generic JSON file reader for non-scheduler call sites.
+ *
+ * Same try/parse/fallback shape as loadStateFile but with a `silent`
+ * option for callers who expect missing files to be common (e.g. a
+ * tool reading an optional config) and don't want every miss to log.
+ *
+ * Six+ files were inlining `try { JSON.parse(readFileSync(p)) } catch
+ * { return default }` before this. They now share one well-tested
+ * helper, which means the next file that needs to read a JSON sidecar
+ * doesn't add a seventh variant.
+ */
+export function loadJsonFile(filePath, defaultValue, opts = {}) {
+    try {
+        if (!existsSync(filePath))
+            return defaultValue;
+        const raw = JSON.parse(readFileSync(filePath, 'utf-8'));
+        return opts.validator ? opts.validator(raw) : raw;
+    }
+    catch (err) {
+        if (!opts.silent) {
+            logger.warn({ err, filePath }, 'Failed to load JSON file — using default');
+        }
+        return defaultValue;
+    }
+}
 /**
  * Write a JSON state file. Creates the parent directory if missing.
  * Returns true on success, false on failure (always logs a warning

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

@@ -31,5 +31,20 @@ export interface BrainIngestFolderResult {
     message: string;
 }
 export declare function ingestBrainRecords(slug: string, records: IngestRecordInput[]): Promise<BrainIngestFolderResult>;
+export interface BrainSaveInput {
+    /** Either a URL (will be fetched) or raw text content. */
+    content: string;
+    /** Optional human-readable title. Inferred from <title> tag for HTML URLs. */
+    title?: string;
+    /** Logical bucket the record belongs to. Default: "chat-saves". */
+    slug?: string;
+    /** Stable id so repeat saves dedupe. Default: hash of content. */
+    externalId?: string;
+    /** Free-form tags carried in frontmatter for later filtering/recall. */
+    tags?: string[];
+}
+export declare function brainSave(input: BrainSaveInput): Promise<BrainIngestFolderResult & {
+    sourceType: 'url' | 'text';
+}>;
 export declare function registerBrainTools(server: McpServer): void;
 //# sourceMappingURL=brain-tools.d.ts.map

package/dist/tools/brain-tools.js

@@ -125,7 +125,120 @@ export async function ingestBrainRecords(slug, records) {
         message,
     };
 }
+// ── brain_save — one-shot ingestion from chat ─────────────────────────
+//
+// 1.18.145 — closes the chat-parity gap on the write side. The user
+// can now say "save this article" or "ingest this URL" and the agent
+// drives the same pipeline the dashboard's Seed tab uses, no manual
+// record assembly required.
+//
+// Accepts either raw text or a URL. URLs are fetched + reasonably
+// extracted (HTML→text via regex strip, JSON/markdown passthrough);
+// for richer extraction the user should still use the dashboard's
+// adapter pipeline (PDF/DOCX/CSV/etc. — they need parsers we don't
+// want to import into every chat session).
+const URL_LIKE = /^https?:\/\//i;
+function looksLikeUrl(s) {
+    return URL_LIKE.test(s.trim());
+}
+async function fetchUrlText(url, timeoutMs = 20_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': 'Clementine/brain_save (compatible; +https://github.com/Natebreynolds/Clementine-AI-Assistant)' },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        const contentType = res.headers.get('content-type') ?? '';
+        const raw = await res.text();
+        if (/json/i.test(contentType)) {
+            return { text: raw, contentType };
+        }
+        if (/html/i.test(contentType) || /^\s*<!DOCTYPE|^\s*<html/i.test(raw)) {
+            // Crude HTML→text. Good enough for "save this article" — anything
+            // fancier (Readability, Mercury) is a dashboard concern.
+            const titleMatch = raw.match(/<title[^>]*>([^<]+)<\/title>/i);
+            const title = titleMatch ? titleMatch[1].trim() : undefined;
+            const text = raw
+                .replace(/<script[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[\s\S]*?<\/style>/gi, '')
+                .replace(/<[^>]+>/g, ' ')
+                .replace(/&nbsp;/g, ' ')
+                .replace(/&amp;/g, '&')
+                .replace(/&lt;/g, '<')
+                .replace(/&gt;/g, '>')
+                .replace(/&quot;/g, '"')
+                .replace(/&#39;/g, "'")
+                .replace(/\s+/g, ' ')
+                .trim();
+            return { text, title, contentType };
+        }
+        // Plaintext, markdown, etc.
+        return { text: raw, contentType };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function brainSave(input) {
+    const slug = sanitizeSlug(input.slug || 'chat-saves');
+    const isUrl = looksLikeUrl(input.content);
+    let text = input.content;
+    let title = input.title;
+    let urlContentType;
+    if (isUrl) {
+        const fetched = await fetchUrlText(input.content);
+        text = fetched.text;
+        title = title || fetched.title || input.content;
+        urlContentType = fetched.contentType;
+    }
+    if (!text || !text.trim()) {
+        throw new Error('brain_save: content is empty after fetch/extract');
+    }
+    // Stable id: caller-provided OR URL-as-id OR sha-style hash of text
+    const externalId = input.externalId
+        || (isUrl ? input.content : fallbackExternalId(slug, 0, text));
+    const metadata = {
+        savedFromChat: true,
+        sourceType: isUrl ? 'url' : 'text',
+    };
+    if (isUrl)
+        metadata.url = input.content;
+    if (urlContentType)
+        metadata.contentType = urlContentType;
+    if (input.tags && input.tags.length)
+        metadata.tags = input.tags;
+    const result = await ingestBrainRecords(slug, [{
+            title: title || 'Untitled',
+            externalId,
+            content: text,
+            metadata,
+        }]);
+    return { ...result, sourceType: isUrl ? 'url' : 'text' };
+}
 export function registerBrainTools(server) {
+    server.tool('brain_save', 'Save a single piece of content (text or URL) to the brain right now. Use when the user says things like "remember this", "save this article", "ingest this URL", "add to memory". Routes through the same distillation pipeline the dashboard\'s Seed tab uses (chunking + LLM summary + vault note + memory index + knowledge graph). For batch ingestion or recurring feeds, see brain_ingest_folder + schedule_skill.', {
+        content: z.string().describe('Either a URL (fetched + text-extracted) or raw text content.'),
+        title: z.string().optional().describe('Optional human-readable title. Inferred from <title> tag for HTML URLs.'),
+        slug: z.string().optional().describe('Logical bucket (folder) the record lands in under 04-Ingest/<slug>/. Default: "chat-saves".'),
+        externalId: z.string().optional().describe('Stable id so repeat saves dedupe (e.g. URL, message id). Default: hash of content.'),
+        tags: z.array(z.string()).optional().describe('Free-form tags persisted in frontmatter for later filtering/recall.'),
+    }, async (input) => {
+        try {
+            const result = await brainSave(input);
+            const where = `04-Ingest/${result.slug}/`;
+            return textResult(`Saved to brain (${result.sourceType}): "${(input.title || input.content).slice(0, 80)}"\n` +
+                `Folder: ${where} · Pipeline: ${result.pipeline.recordsIn} in · ${result.pipeline.recordsWritten} written · ${result.pipeline.recordsSkipped} skipped` +
+                (result.pipeline.recordsFailed > 0 ? ` · ${result.pipeline.recordsFailed} failed` : ''));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error({ err }, 'brain_save: failed');
+            return textResult(`brain_save failed: ${msg}`);
+        }
+    });
     server.tool('brain_ingest_folder', 'Ingest a batch of records into the brain under a named slug. Sends records directly into the distillation pipeline (chunking, LLM summarization, vault note write, memory indexing, knowledge graph write). Use at the end of Connector Feed cron jobs. Safe to re-run — records with the same externalId update the same distilled note.', {
         slug: z.string().describe('Feed slug (matches 04-Ingest/<slug> folder). Lowercase, hyphen-separated.'),
         records: z.array(z.object({

package/dist/tools/mcp-server.js

@@ -31,6 +31,7 @@ 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';
+import { registerScheduleTools } from './schedule-tools.js';
 // ── Server ──────────────────────────────────────────────────────────────
 const serverName = (env['ASSISTANT_NAME'] ?? 'Clementine').toLowerCase() + '-tools';
 const server = new McpServer({ name: serverName, version: '1.0.0' });
@@ -75,6 +76,7 @@ registerBackgroundTaskTools(scopedServer);
 registerDecisionReflectionTools(scopedServer);
 registerBuilderTools(scopedServer);
 registerSkillTools(scopedServer);
+registerScheduleTools(scopedServer);
 // ── Main ────────────────────────────────────────────────────────────────
 async function main() {
     // Initialize memory store and run full sync on startup

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

@@ -0,0 +1,17 @@
+/**
+ * Clementine TypeScript — Schedule MCP tools.
+ *
+ * Thin chat-facing wrappers around src/agent/schedule-registry.ts so
+ * the agent can compose the full automation flow from natural language:
+ *
+ *   user: "scrape Drive every 2 days for AI articles, save to memory"
+ *   agent: 1. create_skill('drive-ai-scraper', { body: '...' })
+ *          2. schedule_skill('drive-ai-scraper', '0 9 *_/2 * *')  (comment elides slash)
+ *
+ * 1.18.145 — closes the chat-parity gap on the automation side. Before
+ * this, the agent could create skills but had no way to schedule them
+ * recurringly without dropping to the dashboard.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerScheduleTools(server: McpServer): void;
+//# sourceMappingURL=schedule-tools.d.ts.map

package/dist/tools/schedule-tools.js

@@ -0,0 +1,105 @@
+/**
+ * Clementine TypeScript — Schedule MCP tools.
+ *
+ * Thin chat-facing wrappers around src/agent/schedule-registry.ts so
+ * the agent can compose the full automation flow from natural language:
+ *
+ *   user: "scrape Drive every 2 days for AI articles, save to memory"
+ *   agent: 1. create_skill('drive-ai-scraper', { body: '...' })
+ *          2. schedule_skill('drive-ai-scraper', '0 9 *_/2 * *')  (comment elides slash)
+ *
+ * 1.18.145 — closes the chat-parity gap on the automation side. Before
+ * this, the agent could create skills but had no way to schedule them
+ * recurringly without dropping to the dashboard.
+ */
+import { z } from 'zod';
+import cron from 'node-cron';
+import { listSchedules, getSchedule, setSchedule, removeSchedule, enableSchedule, } from '../agent/schedule-registry.js';
+import { loadSkillByName } from '../agent/skill-extractor.js';
+import { textResult, logger } from './shared.js';
+export function registerScheduleTools(server) {
+    server.tool('schedule_skill', 'Schedule a skill to run automatically on a cron expression. Pair with create_skill to build "recurring brain feeds" or any other automation from chat. The skill must already exist in the catalog. Idempotent — calling twice for the same skill updates the existing schedule. Use enabled=false to pause without losing the schedule.', {
+        skillName: z.string().describe('The skill slug (must already exist in the catalog — call create_skill first if needed).'),
+        schedule: z.string().describe('Cron expression. Examples: "0 9 * * *" = daily 9am, "0 9 */2 * *" = every 2 days at 9am, "0 */4 * * *" = every 4 hours, "0 7 * * 1-5" = weekdays at 7am.'),
+        enabled: z.boolean().optional().describe('When false, schedule is saved but the runner skips it. Default: true.'),
+        agentSlug: z.string().nullable().optional().describe('Optional: run as a hired agent (e.g. "ross-the-sdr"). Default: null = Clementine.'),
+    }, async ({ skillName, schedule, enabled, agentSlug }) => {
+        // Validate cron expression up-front so the user gets a clear
+        // error before we touch the registry.
+        if (!cron.validate(schedule)) {
+            return textResult(`schedule_skill: "${schedule}" is not a valid cron expression. Try something like "0 9 * * *" (daily 9am).`);
+        }
+        // Validate the skill exists. Without this, the schedule would
+        // silently sit in the registry and the cron scheduler would skip
+        // it on every fire — confusing failure mode.
+        const skill = loadSkillByName(skillName, agentSlug ?? undefined);
+        if (!skill) {
+            return textResult(`schedule_skill: skill "${skillName}" not found${agentSlug ? ` (in agent "${agentSlug}" scope)` : ''}. ` +
+                `Create it first with create_skill, then schedule it.`);
+        }
+        try {
+            const entry = setSchedule(skillName, {
+                schedule,
+                enabled: enabled ?? true,
+                agentSlug: agentSlug ?? null,
+            });
+            logger.info({ skillName, schedule, enabled: entry.enabled, agentSlug: entry.agentSlug }, 'schedule_skill: scheduled');
+            return textResult(`Scheduled "${skillName}" to run on "${schedule}"` +
+                (entry.enabled ? '' : ' (DISABLED — flip enabled:true to start firing)') +
+                `. View on the Tasks page or call list_schedules to confirm.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error({ err, skillName }, 'schedule_skill: failed');
+            return textResult(`schedule_skill failed: ${msg}`);
+        }
+    });
+    server.tool('list_schedules', 'List every scheduled skill and its cron expression. Returns the same data the dashboard\'s Tasks page shows for the SKILL-tagged rows.', {}, async () => {
+        try {
+            const entries = listSchedules();
+            if (entries.length === 0) {
+                return textResult('No scheduled skills yet. Use schedule_skill to create one.');
+            }
+            const lines = [`${entries.length} scheduled skill${entries.length === 1 ? '' : 's'}:`];
+            for (const e of entries) {
+                const status = e.enabled ? '✓' : '⏸';
+                const owner = e.agentSlug ? ` (as ${e.agentSlug})` : '';
+                lines.push(`${status} ${e.skillName} — ${e.schedule}${owner}`);
+            }
+            return textResult(lines.join('\n'));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`list_schedules failed: ${msg}`);
+        }
+    });
+    server.tool('unschedule_skill', 'Remove a skill\'s schedule entirely. The skill stays in the catalog and can still be run manually or rescheduled later. Use pause_schedule (enabled:false via schedule_skill) for a temporary pause instead.', {
+        skillName: z.string().describe('The skill slug to unschedule.'),
+    }, async ({ skillName }) => {
+        const existing = getSchedule(skillName);
+        if (!existing) {
+            return textResult(`unschedule_skill: "${skillName}" wasn't scheduled — nothing to do.`);
+        }
+        try {
+            removeSchedule(skillName);
+            logger.info({ skillName }, 'unschedule_skill: removed');
+            return textResult(`Unscheduled "${skillName}". The skill stays in the catalog and can be run manually.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`unschedule_skill failed: ${msg}`);
+        }
+    });
+    server.tool('pause_schedule', 'Pause or resume an existing scheduled skill without losing its cron expression. Equivalent to schedule_skill with enabled:false but doesn\'t require re-passing the schedule string.', {
+        skillName: z.string().describe('The skill slug.'),
+        enabled: z.boolean().describe('true = resume firing, false = pause.'),
+    }, async ({ skillName, enabled }) => {
+        const updated = enableSchedule(skillName, enabled);
+        if (!updated) {
+            return textResult(`pause_schedule: "${skillName}" isn't scheduled. Use schedule_skill to create the schedule first.`);
+        }
+        logger.info({ skillName, enabled }, 'pause_schedule: updated');
+        return textResult(`${enabled ? 'Resumed' : 'Paused'} "${skillName}" (${updated.schedule}).`);
+    });
+}
+//# sourceMappingURL=schedule-tools.js.map

package/dist/tools/shared.d.ts

@@ -676,6 +676,15 @@ export declare function agentTasksFile(slug: string | null): string;
 export declare function agentWorkingMemoryFile(slug: string | null): string;
 export declare function agentGoalsDir(slug: string | null): string;
 export declare function agentDailyNotesDir(slug: string | null): string;
+/**
+ * 1.18.144 — Single source of truth for "all currently-hired agent
+ * slugs." Five+ files used to inline the same readdirSync + filter
+ * pattern (skipping leading-underscore directories like _archive).
+ *
+ * Returns slugs sorted alphabetically. Returns [] when AGENTS_DIR
+ * doesn't exist or can't be read.
+ */
+export declare function listAgentSlugs(): string[];
 export type GoalRecord = {
     id: string;
     title: string;

package/dist/tools/shared.js

@@ -80,6 +80,27 @@ export function agentDailyNotesDir(slug) {
         return DAILY_NOTES_DIR;
     return path.join(AGENTS_DIR, slug, 'daily-notes');
 }
+/**
+ * 1.18.144 — Single source of truth for "all currently-hired agent
+ * slugs." Five+ files used to inline the same readdirSync + filter
+ * pattern (skipping leading-underscore directories like _archive).
+ *
+ * Returns slugs sorted alphabetically. Returns [] when AGENTS_DIR
+ * doesn't exist or can't be read.
+ */
+export function listAgentSlugs() {
+    if (!existsSync(AGENTS_DIR))
+        return [];
+    try {
+        return readdirSync(AGENTS_DIR, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && !d.name.startsWith('_'))
+            .map((d) => d.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
 /** Return the directory where a goal owned by `owner` should live. */
 export function goalDirForOwner(owner) {
     if (!owner || owner === 'clementine')

package/dist/tools/skill-tools.js

@@ -25,7 +25,10 @@ import { VAULT_DIR, textResult, logger } from './shared.js';
 // 1.18.124 — name regex is the only validator skill-tools still uses
 // directly (for update_skill's pre-flight slug check). All other
 // validations + the file write live in skill-store.writeSkill.
-const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+// 1.18.144 — pulled the regex from skill-store's exported canonical
+// constant so all skill-name validation now traces to one source.
+import { ANTHROPIC_SKILL_NAME_PATTERN } from '../agent/skill-store.js';
+const NAME_PATTERN = ANTHROPIC_SKILL_NAME_PATTERN;
 const DESCRIPTION_MAX_LEN = 1024;
 function globalSkillsDir() {
     return path.join(VAULT_DIR, '00-System', 'skills');

package/dist/tools/team-tools.js

@@ -7,13 +7,14 @@ import path from 'node:path';
 import { z } from 'zod';
 import { ACTIVE_AGENT_SLUG, AGENTS_DIR, BASE_DIR, DELEGATIONS_BASE, TEAM_COMMS_LOG, env, logger, parseTasks, textResult, } from './shared.js';
 import { todayISO } from '../gateway/cron-scheduler.js';
+import { listAgentSlugs } from './shared.js';
 async function loadTeamAgents() {
     const matterMod = await import('gray-matter');
     const agents = [];
     const seen = new Set();
     if (existsSync(AGENTS_DIR)) {
         try {
-            for (const slug of readdirSync(AGENTS_DIR, { withFileTypes: true }).filter(d => d.isDirectory() && !d.name.startsWith('_')).map(d => d.name)) {
+            for (const slug of listAgentSlugs()) {
                 const agentFile = path.join(AGENTS_DIR, slug, 'agent.md');
                 if (!existsSync(agentFile))
                     continue;
@@ -349,10 +350,7 @@ export function registerTeamTools(server) {
         const agentsBase = AGENTS_DIR;
         if (!existsSync(agentsBase))
             return textResult('No agents found.');
-        const agentSlugs = readdirSync(agentsBase, { withFileTypes: true })
-            .filter(d => d.isDirectory())
-            .map(d => d.name)
-            .filter(n => !agent || n === agent);
+        const agentSlugs = listAgentSlugs().filter(n => !agent || n === agent);
         if (!agentSlugs.length)
             return textResult('No agents found.');
         const matterMod = await import('gray-matter');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.143",
+  "version": "1.18.145",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,7 @@
     "postinstall": "node scripts/postinstall.js 2>/dev/null || true"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.137",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.138",
     "@anthropic-ai/sdk": "^0.91.0",
     "@composio/claude-agent-sdk": "^0.8.1",
     "@composio/core": "^0.8.1",