clementine-agent 1.0.11 → 1.0.13

package/dist/cli/routes/goals.js

@@ -1,79 +1,73 @@
 /**
- * Goals API routes — extracted from dashboard.ts
+ * Goals API routes — extracted from dashboard.ts.
+ *
+ * Goals live per-owner: Clementine's at ~/.clementine/goals/, each agent's at
+ * ~/.clementine/vault/00-System/agents/{slug}/goals/. Uses the goal-store
+ * helpers in tools/shared.ts so the dashboard doesn't need to know the layout.
  */
 import { Router } from 'express';
 import express from 'express';
-import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, unlinkSync, } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync, } from 'node:fs';
 import path from 'node:path';
 import matter from 'gray-matter';
+import { listAllGoals, findGoalPath, readGoalById, writeGoalForOwner } from '../../tools/shared.js';
 export function goalsRouter(deps) {
     const router = Router();
-    const { goalsDir, cronRunsDir, vaultDir, cronFile, getGateway } = deps;
+    const { cronRunsDir, vaultDir, cronFile, getGateway } = deps;
     // List goals with contributions + delegations
     router.get('/progress', (_req, res) => {
-        if (!existsSync(goalsDir)) {
-            res.json({ goals: [] });
-            return;
-        }
         try {
-            const files = readdirSync(goalsDir).filter(f => f.endsWith('.json'));
-            const goals = files.map(f => {
-                try {
-                    const goal = JSON.parse(readFileSync(path.join(goalsDir, f), 'utf-8'));
-                    const agentContributions = {};
-                    if (goal.linkedCronJobs?.length && existsSync(cronRunsDir)) {
-                        for (const jobName of goal.linkedCronJobs) {
-                            const safe = jobName.replace(/[^a-zA-Z0-9_-]/g, '_');
-                            const logFile = path.join(cronRunsDir, `${safe}.jsonl`);
-                            if (!existsSync(logFile))
+            const goals = listAllGoals().map(({ goal, owner }) => {
+                const agentContributions = {};
+                if (goal.linkedCronJobs?.length && existsSync(cronRunsDir)) {
+                    for (const jobName of goal.linkedCronJobs) {
+                        const safe = jobName.replace(/[^a-zA-Z0-9_-]/g, '_');
+                        const logFile = path.join(cronRunsDir, `${safe}.jsonl`);
+                        if (!existsSync(logFile))
+                            continue;
+                        const lines = readFileSync(logFile, 'utf-8').trim().split('\n').filter(Boolean);
+                        for (const line of lines.slice(-20)) {
+                            try {
+                                const entry = JSON.parse(line);
+                                const agent = entry.agentSlug || jobName;
+                                if (!agentContributions[agent])
+                                    agentContributions[agent] = { runs: 0, successes: 0 };
+                                agentContributions[agent].runs++;
+                                if (entry.status === 'ok')
+                                    agentContributions[agent].successes++;
+                                agentContributions[agent].lastRun = entry.finishedAt;
+                            }
+                            catch {
                                 continue;
-                            const lines = readFileSync(logFile, 'utf-8').trim().split('\n').filter(Boolean);
-                            for (const line of lines.slice(-20)) {
-                                try {
-                                    const entry = JSON.parse(line);
-                                    const agent = entry.agentSlug || jobName;
-                                    if (!agentContributions[agent])
-                                        agentContributions[agent] = { runs: 0, successes: 0 };
-                                    agentContributions[agent].runs++;
-                                    if (entry.status === 'ok')
-                                        agentContributions[agent].successes++;
-                                    agentContributions[agent].lastRun = entry.finishedAt;
-                                }
-                                catch {
-                                    continue;
-                                }
                             }
                         }
                     }
-                    const delegationsDir = path.join(vaultDir, '00-System', 'agents');
-                    const delegations = [];
-                    if (existsSync(delegationsDir)) {
-                        try {
-                            for (const agentDir of readdirSync(delegationsDir)) {
-                                const tasksDir = path.join(delegationsDir, agentDir, 'delegations');
-                                if (!existsSync(tasksDir))
-                                    continue;
-                                for (const tf of readdirSync(tasksDir).filter(tf => tf.endsWith('.json'))) {
-                                    try {
-                                        const task = JSON.parse(readFileSync(path.join(tasksDir, tf), 'utf-8'));
-                                        if (task.goalId === goal.id) {
-                                            delegations.push({ agent: task.toAgent || agentDir, task: task.task || tf, status: task.status || 'pending' });
-                                        }
-                                    }
-                                    catch {
-                                        continue;
+                }
+                const delegationsDir = path.join(vaultDir, '00-System', 'agents');
+                const delegations = [];
+                if (existsSync(delegationsDir)) {
+                    try {
+                        for (const agentDir of readdirSync(delegationsDir)) {
+                            const tasksDir = path.join(delegationsDir, agentDir, 'delegations');
+                            if (!existsSync(tasksDir))
+                                continue;
+                            for (const tf of readdirSync(tasksDir).filter(tf => tf.endsWith('.json'))) {
+                                try {
+                                    const task = JSON.parse(readFileSync(path.join(tasksDir, tf), 'utf-8'));
+                                    if (task.goalId === goal.id) {
+                                        delegations.push({ agent: task.toAgent || agentDir, task: task.task || tf, status: task.status || 'pending' });
                                     }
                                 }
+                                catch {
+                                    continue;
+                                }
                             }
                         }
-                        catch { /* ignore */ }
                     }
-                    return { ...goal, agentContributions, delegations };
-                }
-                catch {
-                    return null;
+                    catch { /* ignore */ }
                 }
-            }).filter(Boolean);
+                return { ...goal, owner, agentContributions, delegations };
+            });
             res.json({ goals });
         }
         catch {
@@ -83,8 +77,6 @@ export function goalsRouter(deps) {
     // Create goal
     router.post('/', express.json(), (req, res) => {
         try {
-            if (!existsSync(goalsDir))
-                mkdirSync(goalsDir, { recursive: true });
             const id = Math.random().toString(16).slice(2, 10);
             const { title, description, owner, priority, status, targetDate, linkedCronJobs, nextActions, blockers, reviewFrequency } = req.body;
             if (!title) {
@@ -99,7 +91,7 @@ export function goalsRouter(deps) {
                 reviewFrequency: reviewFrequency || 'weekly', linkedCronJobs: linkedCronJobs || [],
                 targetDate: targetDate || undefined,
             };
-            writeFileSync(path.join(goalsDir, `${id}.json`), JSON.stringify(goal, null, 2));
+            writeGoalForOwner(goal);
             res.json({ ok: true, goal });
         }
         catch (e) {
@@ -109,19 +101,21 @@ export function goalsRouter(deps) {
     // Update goal
     router.put('/:id', express.json(), (req, res) => {
         try {
-            const goalPath = path.join(goalsDir, `${req.params.id}.json`);
-            if (!existsSync(goalPath)) {
+            const found = findGoalPath(req.params.id);
+            if (!found) {
+                res.status(404).json({ ok: false, error: 'Goal not found' });
+                return;
+            }
+            const existing = readGoalById(req.params.id);
+            if (!existing) {
                 res.status(404).json({ ok: false, error: 'Goal not found' });
                 return;
             }
-            const existing = JSON.parse(readFileSync(goalPath, 'utf-8'));
             const { title, description, owner, priority, status, targetDate, linkedCronJobs, nextActions, blockers, reviewFrequency } = req.body;
             if (title !== undefined)
                 existing.title = title;
             if (description !== undefined)
                 existing.description = description;
-            if (owner !== undefined)
-                existing.owner = owner;
             if (priority !== undefined)
                 existing.priority = priority;
             if (status !== undefined)
@@ -137,7 +131,21 @@ export function goalsRouter(deps) {
             if (reviewFrequency !== undefined)
                 existing.reviewFrequency = reviewFrequency;
             existing.updatedAt = new Date().toISOString();
-            writeFileSync(goalPath, JSON.stringify(existing, null, 2));
+            // If owner changed, re-route to the new owner's dir and remove from old location.
+            // Write the new copy first so we don't lose the goal if unlink fails.
+            if (owner !== undefined && owner !== found.owner) {
+                existing.owner = owner;
+                writeGoalForOwner(existing);
+                try {
+                    unlinkSync(found.filePath);
+                }
+                catch (unlinkErr) {
+                    console.warn(`[goals] Failed to remove old goal file ${found.filePath} after owner change to ${owner}:`, unlinkErr);
+                }
+            }
+            else {
+                writeFileSync(found.filePath, JSON.stringify(existing, null, 2));
+            }
             res.json({ ok: true, goal: existing });
         }
         catch (e) {
@@ -147,12 +155,12 @@ export function goalsRouter(deps) {
     // Delete goal
     router.delete('/:id', (_req, res) => {
         try {
-            const goalPath = path.join(goalsDir, `${_req.params.id}.json`);
-            if (!existsSync(goalPath)) {
+            const found = findGoalPath(_req.params.id);
+            if (!found) {
                 res.status(404).json({ ok: false, error: 'Goal not found' });
                 return;
             }
-            unlinkSync(goalPath);
+            unlinkSync(found.filePath);
             res.json({ ok: true });
         }
         catch (e) {
@@ -162,12 +170,11 @@ export function goalsRouter(deps) {
     // Generate cron proposals from goal
     router.post('/:id/generate-crons', async (req, res) => {
         try {
-            const goalPath = path.join(goalsDir, `${req.params.id}.json`);
-            if (!existsSync(goalPath)) {
+            const goal = readGoalById(req.params.id);
+            if (!goal) {
                 res.status(404).json({ ok: false, error: 'Goal not found' });
                 return;
             }
-            const goal = JSON.parse(readFileSync(goalPath, 'utf-8'));
             const prompt = `You are analyzing a goal and proposing automated scheduled tasks (cron jobs) to make progress on it.
 
 ## Goal: ${goal.title}
@@ -213,12 +220,16 @@ Respond ONLY with valid JSON:
     // Approve cron proposals
     router.post('/:id/approve-crons', express.json(), (req, res) => {
         try {
-            const goalPath = path.join(goalsDir, `${req.params.id}.json`);
-            if (!existsSync(goalPath)) {
+            const found = findGoalPath(req.params.id);
+            if (!found) {
+                res.status(404).json({ ok: false, error: 'Goal not found' });
+                return;
+            }
+            const goal = readGoalById(req.params.id);
+            if (!goal) {
                 res.status(404).json({ ok: false, error: 'Goal not found' });
                 return;
             }
-            const goal = JSON.parse(readFileSync(goalPath, 'utf-8'));
             const crons = req.body.crons || [];
             if (crons.length === 0) {
                 res.status(400).json({ ok: false, error: 'No crons to approve' });
@@ -245,7 +256,7 @@ Respond ONLY with valid JSON:
                         goal.linkedCronJobs.push(name);
                 }
                 goal.updatedAt = new Date().toISOString();
-                writeFileSync(goalPath, JSON.stringify(goal, null, 2));
+                writeFileSync(found.filePath, JSON.stringify(goal, null, 2));
             }
             res.json({ ok: true, added, skipped: crons.length - added.length });
         }

package/dist/gateway/cron-scheduler.js

@@ -13,6 +13,7 @@ import cron from 'node-cron';
 import matter from 'gray-matter';
 import pino from 'pino';
 import { CRON_FILE, WORKFLOWS_DIR, AGENTS_DIR, DAILY_NOTES_DIR, BASE_DIR, DISCORD_OWNER_ID, GOALS_DIR, CRON_REFLECTIONS_DIR, ADVISOR_LOG_PATH, TIMEZONE, } from '../config.js';
+import { listAllGoals, findGoalPath, readGoalById } from '../tools/shared.js';
 import { scanner } from '../security/scanner.js';
 import { parseAllWorkflows as parseAllWorkflowsSync } from '../agent/workflow-runner.js';
 import { SelfImproveLoop } from '../agent/self-improve.js';
@@ -1154,6 +1155,13 @@ export class CronScheduler {
         const trimmed = response.trim();
         if (trimmed === '__NOTHING__')
             return true;
+        // Bare "NOTHING" (with or without underscores/parenthetical), matching heartbeat scheduler.
+        if (/^_*NOTHING_*\s*(\(|$)/im.test(trimmed))
+            return true;
+        // Goal-work [MONITORING] classification with no substantive body —
+        // Clementine checked the goal and nothing changed, so suppress the notification.
+        if (/^(_*NOTHING_*\s*)?\[MONITORING\]\s*$/i.test(trimmed))
+            return true;
         // Only treat as noise if the response is short — avoids filtering out
         // substantive responses that happen to start with "No updates, but..."
         if (trimmed.length > 80)
@@ -1418,13 +1426,14 @@ export class CronScheduler {
                 unlinkSync(filePath);
                 if (!trigger.goalId)
                     continue;
-                const goalPath = path.join(GOALS_DIR, `${trigger.goalId}.json`);
-                if (!existsSync(goalPath)) {
+                const found = findGoalPath(trigger.goalId);
+                if (!found) {
                     logger.warn({ goalId: trigger.goalId }, 'Goal trigger references missing goal — skipping');
                     continue;
                 }
-                const goal = JSON.parse(readFileSync(goalPath, 'utf-8'));
-                if (goal.status !== 'active')
+                const goalPath = found.filePath;
+                const goal = readGoalById(trigger.goalId);
+                if (!goal || goal.status !== 'active')
                     continue;
                 logger.info({ goalId: trigger.goalId, title: goal.title, focus: trigger.focus }, 'Processing goal work trigger');
                 // Load recent progress outcomes so the agent has context about what it already did
@@ -1455,14 +1464,14 @@ export class CronScheduler {
                 const prompt = `You are working on a focused goal session.\n\n` +
                     `## Goal: ${goal.title}\n${goal.description}\n\n` +
                     `## Focus for this session\n${trigger.focus}\n\n` +
-                    (goal.progressNotes?.length > 0
+                    (goal.progressNotes && goal.progressNotes.length > 0
                         ? `## Prior progress\n${goal.progressNotes.slice(-5).map((n) => `- ${n}`).join('\n')}\n\n`
                         : '') +
                     recentOutcomesContext +
-                    (goal.nextActions?.length > 0
+                    (goal.nextActions && goal.nextActions.length > 0
                         ? `## Planned next actions\n${goal.nextActions.map((a) => `- ${a}`).join('\n')}\n\n`
                         : '') +
-                    (goal.blockers?.length > 0
+                    (goal.blockers && goal.blockers.length > 0
                         ? `## Current blockers\n${goal.blockers.map((b) => `- ${b}`).join('\n')}\n\n`
                         : '') +
                     `## Instructions\n` +
@@ -1477,8 +1486,16 @@ export class CronScheduler {
                     `   - [MONITORING] — checked status, nothing changed, will check again later\n` +
                     `5. Keep your output concise — summarize what you accomplished.`;
                 const jobName = `goal:${goal.title.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 40)}`;
-                const goalSnapshotUpdatedAt = goal.updatedAt;
+                const goalSnapshotUpdatedAt = goal.updatedAt ?? '';
                 const goalSnapshotNotes = goal.progressNotes?.length ?? 0;
+                // Route goal work to the owning agent so the session runs with their
+                // tools/model and output lands in their Discord channel. Clementine-owned
+                // goals continue to run under Clementine's identity.
+                const ownerSlug = (found.owner && found.owner !== 'clementine') ? found.owner : null;
+                const dispatchOpts = ownerSlug ? { agentSlug: ownerSlug } : undefined;
+                if (ownerSlug) {
+                    this.gateway.setSessionProfile(`cron:${jobName}`, ownerSlug);
+                }
                 // ── Route through execution advisor (same path as regular cron jobs) ──
                 // Creates a synthetic CronJobDefinition so the advisor can apply circuit
                 // breakers, turn-limit adjustments, model upgrades, and unleashed escalation.
@@ -1490,6 +1507,7 @@ export class CronScheduler {
                     tier: 2,
                     maxTurns: trigger.maxTurns ?? 15,
                     mode: 'standard',
+                    ...(ownerSlug ? { agentSlug: ownerSlug } : {}),
                 };
                 import('../agent/execution-advisor.js').then(({ getExecutionAdvice }) => {
                     const advice = getExecutionAdvice(jobName, syntheticJob);
@@ -1513,7 +1531,7 @@ export class CronScheduler {
                     this.gateway.handleCronJob(jobName, enrichedPrompt, 2, effectiveMaxTurns, effectiveModel, undefined, // workDir
                     useUnleashed ? 'unleashed' : undefined, useUnleashed ? 1 : undefined).then((result) => {
                         if (result && !CronScheduler.isCronNoise(result)) {
-                            this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
+                            this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`, dispatchOpts).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
                         }
                         logToDailyNote(`**Goal work: ${goal.title}** — ${(result || 'completed').slice(0, 100).replace(/\n/g, ' ')}`);
                         this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, result);
@@ -1526,7 +1544,7 @@ export class CronScheduler {
                     logger.warn({ err, goalId: trigger.goalId }, 'Advisor unavailable — running goal work with defaults');
                     this.gateway.handleCronJob(jobName, prompt, 2, trigger.maxTurns ?? 15).then((result) => {
                         if (result && !CronScheduler.isCronNoise(result)) {
-                            this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
+                            this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`, dispatchOpts).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
                         }
                         logToDailyNote(`**Goal work: ${goal.title}** — ${(result || 'completed').slice(0, 100).replace(/\n/g, ' ')}`);
                         this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, result);
@@ -1597,17 +1615,10 @@ export class CronScheduler {
             return;
         try {
             // Only apply suggestions linked to high-priority autoSchedule goals
-            const goalFiles = existsSync(GOALS_DIR) ? readdirSync(GOALS_DIR).filter(f => f.endsWith('.json')) : [];
             const autoScheduleGoalTitles = new Set();
-            for (const f of goalFiles) {
-                try {
-                    const goal = JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-                    if (goal.status === 'active' && goal.priority === 'high' && goal.autoSchedule) {
-                        autoScheduleGoalTitles.add(goal.title.toLowerCase());
-                    }
-                }
-                catch {
-                    continue;
+            for (const { goal } of listAllGoals()) {
+                if (goal.status === 'active' && goal.priority === 'high' && goal.autoSchedule) {
+                    autoScheduleGoalTitles.add(String(goal.title).toLowerCase());
                 }
             }
             if (autoScheduleGoalTitles.size === 0)

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

@@ -47,11 +47,9 @@ export declare class HeartbeatScheduler {
      */
     private getRecentActivitySummary;
     /**
-     * Read and parse all goal JSON files from GOALS_DIR once. Callers that
-     * need filtered subsets (active only, priority-based, etc.) do their own
-     * filtering over the returned array. Used by heartbeatTick to avoid
-     * repeating the readdirSync+readFileSync pass for every goal-consuming
-     * method.
+     * Read and parse all goal JSON files across Clementine's global goals dir
+     * AND every per-agent goals dir. Callers that need filtered subsets
+     * (active only, priority-based, etc.) do their own filtering.
      */
     static loadAllGoals(): Array<any>;
     /**

package/dist/gateway/heartbeat-scheduler.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import pino from 'pino';
 import { HEARTBEAT_FILE, TASKS_FILE, INBOX_DIR, DAILY_NOTES_DIR, HEARTBEAT_INTERVAL_MINUTES, HEARTBEAT_ACTIVE_START, HEARTBEAT_ACTIVE_END, BASE_DIR, GOALS_DIR, HEARTBEAT_WORK_QUEUE_FILE, DISCORD_OWNER_ID, } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
 import { gatherInsightSignals, buildInsightPrompt, parseInsightResponse, canSendInsight, recordInsightSent, recordInsightAcked, maybeIncreaseCooldown, } from '../agent/insight-engine.js';
 import { CronRunLog, logToDailyNote, todayISO } from './cron-scheduler.js';
 const logger = pino({ name: 'clementine.heartbeat' });
@@ -796,25 +797,16 @@ export class HeartbeatScheduler {
         return lines.join('\n');
     }
     /**
-     * Read and parse all goal JSON files from GOALS_DIR once. Callers that
-     * need filtered subsets (active only, priority-based, etc.) do their own
-     * filtering over the returned array. Used by heartbeatTick to avoid
-     * repeating the readdirSync+readFileSync pass for every goal-consuming
-     * method.
+     * Read and parse all goal JSON files across Clementine's global goals dir
+     * AND every per-agent goals dir. Callers that need filtered subsets
+     * (active only, priority-based, etc.) do their own filtering.
      */
     static loadAllGoals() {
         try {
-            if (!existsSync(GOALS_DIR))
-                return [];
-            const files = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
-            return files
-                .map(f => { try {
-                return JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-            }
-            catch {
-                return null;
-            } })
-                .filter((g) => g !== null);
+            return listAllGoals().map(({ goal, owner }) => ({
+                ...goal,
+                owner: goal.owner || owner,
+            }));
         }
         catch (err) {
             logger.warn({ err }, 'loadAllGoals failed');

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

@@ -1,8 +1,10 @@
 /**
  * Clementine TypeScript — Goal MCP tools.
  *
- * Persistent goals that drive proactive agent behavior and
- * can be linked to cron jobs for autonomous progress.
+ * Persistent goals that survive across sessions and drive proactive behavior.
+ * Goals live per-owner: Clementine's at ~/.clementine/goals/, each agent's at
+ * ~/.clementine/vault/00-System/agents/{slug}/goals/. Helpers in shared.ts
+ * handle routing so tools here don't need to know the layout.
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerGoalTools(server: McpServer): void;