clementine-agent 1.0.11 → 1.0.13

package/dist/tools/goal-tools.js

@@ -1,25 +1,22 @@
 /**
  * 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 { randomBytes } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
-import { BASE_DIR, logger, textResult } from './shared.js';
-const GOALS_DIR = path.join(BASE_DIR, 'goals');
+import { BASE_DIR, logger, textResult, listAllGoals, findGoalPath, readGoalById, writeGoalForOwner, } from './shared.js';
 const GOAL_TRIGGER_DIR = path.join(BASE_DIR, 'cron', 'goal-triggers');
-function ensureGoalsDir() {
-    if (!existsSync(GOALS_DIR))
-        mkdirSync(GOALS_DIR, { recursive: true });
-}
 export function registerGoalTools(server) {
-    server.tool('goal_create', 'Create a new persistent goal that survives across sessions. Goals drive proactive agent behavior and can be linked to cron jobs.', {
+    server.tool('goal_create', 'Create a new persistent goal that survives across sessions. Goals drive proactive agent behavior and can be linked to cron jobs. Agent goals live in that agent\'s own directory.', {
         title: z.string().describe('Short goal title'),
         description: z.string().describe('Detailed description of what this goal aims to achieve'),
-        owner: z.string().optional().describe('Agent slug that owns this goal (default: "clementine")'),
+        owner: z.string().optional().describe('Agent slug that owns this goal (default: "clementine"). Goal file is routed to the owner\'s directory.'),
         priority: z.enum(['high', 'medium', 'low']).optional().describe('Priority level (default: "medium")'),
         targetDate: z.string().optional().describe('Target completion date (YYYY-MM-DD)'),
         nextActions: z.array(z.string()).optional().describe('Initial next actions to take'),
@@ -27,7 +24,6 @@ export function registerGoalTools(server) {
         linkedCronJobs: z.array(z.string()).optional().describe('Cron job names that contribute to this goal'),
         autoSchedule: z.boolean().optional().describe('Allow the daily planner to auto-create/adjust cron jobs for this goal (default: false)'),
     }, async ({ title, description, owner, priority, targetDate, nextActions, reviewFrequency, linkedCronJobs, autoSchedule }) => {
-        ensureGoalsDir();
         const id = randomBytes(4).toString('hex');
         const now = new Date().toISOString();
         const goal = {
@@ -43,9 +39,9 @@ export function registerGoalTools(server) {
             linkedCronJobs: linkedCronJobs || [],
             ...(autoSchedule ? { autoSchedule } : {}),
         };
-        writeFileSync(path.join(GOALS_DIR, `${id}.json`), JSON.stringify(goal, null, 2));
-        logger.info({ goalId: id, title }, 'Goal created');
-        return textResult(`Goal created: "${title}" (ID: ${id})`);
+        const filePath = writeGoalForOwner(goal);
+        logger.info({ goalId: id, title, owner: goal.owner, filePath }, 'Goal created');
+        return textResult(`Goal created: "${title}" (ID: ${id}) — owner: ${goal.owner}`);
     });
     server.tool('goal_update', 'Update an existing persistent goal — add progress notes, change status, update next actions, or add blockers.', {
         id: z.string().describe('Goal ID'),
@@ -57,14 +53,16 @@ export function registerGoalTools(server) {
         priority: z.enum(['high', 'medium', 'low']).optional().describe('Change priority'),
         autoSchedule: z.boolean().optional().describe('Allow the daily planner to auto-create/adjust cron jobs for this goal'),
     }, async ({ id, status, progressNote, nextActions, blockers, linkedCronJobs, priority, autoSchedule }) => {
-        const filePath = path.join(GOALS_DIR, `${id}.json`);
-        if (!existsSync(filePath))
+        const found = findGoalPath(id);
+        if (!found)
+            return textResult(`Goal not found: ${id}`);
+        const goal = readGoalById(id);
+        if (!goal)
             return textResult(`Goal not found: ${id}`);
-        const goal = JSON.parse(readFileSync(filePath, 'utf-8'));
         if (status)
             goal.status = status;
         if (progressNote)
-            goal.progressNotes.push(`[${new Date().toISOString().slice(0, 16)}] ${progressNote}`);
+            (goal.progressNotes ||= []).push(`[${new Date().toISOString().slice(0, 16)}] ${progressNote}`);
         if (nextActions)
             goal.nextActions = nextActions;
         if (blockers)
@@ -76,42 +74,32 @@ export function registerGoalTools(server) {
         if (autoSchedule !== undefined)
             goal.autoSchedule = autoSchedule;
         goal.updatedAt = new Date().toISOString();
-        writeFileSync(filePath, JSON.stringify(goal, null, 2));
-        logger.info({ goalId: id, status: goal.status }, 'Goal updated');
+        writeFileSync(found.filePath, JSON.stringify(goal, null, 2));
+        logger.info({ goalId: id, status: goal.status, owner: found.owner }, 'Goal updated');
         return textResult(`Goal "${goal.title}" updated (status: ${goal.status})`);
     });
-    server.tool('goal_list', 'List persistent goals, optionally filtered by owner or status.', {
+    server.tool('goal_list', 'List persistent goals, optionally filtered by owner or status. Walks Clementine\'s global goals dir plus every agent\'s goals dir.', {
         owner: z.string().optional().describe('Filter by owner agent slug'),
         status: z.enum(['active', 'paused', 'completed', 'blocked']).optional().describe('Filter by status'),
     }, async ({ owner, status }) => {
-        ensureGoalsDir();
-        const files = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
-        let goals = files.map(f => {
-            try {
-                return JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-            }
-            catch {
-                return null;
-            }
-        }).filter(Boolean);
+        let entries = listAllGoals();
         if (owner)
-            goals = goals.filter((g) => g.owner === owner);
+            entries = entries.filter(e => e.owner === owner);
         if (status)
-            goals = goals.filter((g) => g.status === status);
-        if (goals.length === 0)
+            entries = entries.filter(e => e.goal.status === status);
+        if (entries.length === 0)
             return textResult('No goals found matching the criteria.');
-        const lines = goals.map((g) => {
-            const nextAct = g.nextActions?.length > 0 ? ` | Next: ${g.nextActions[0]}` : '';
-            const linked = g.linkedCronJobs?.length > 0 ? ` | Crons: ${g.linkedCronJobs.join(', ')}` : '';
-            return `- [${g.status.toUpperCase()}] **${g.title}** (${g.id}) — ${g.priority} priority, owner: ${g.owner}${nextAct}${linked}`;
+        const lines = entries.map(({ goal, owner: goalOwner }) => {
+            const nextAct = goal.nextActions?.length ? ` | Next: ${goal.nextActions[0]}` : '';
+            const linked = goal.linkedCronJobs?.length ? ` | Crons: ${goal.linkedCronJobs.join(', ')}` : '';
+            return `- [${String(goal.status).toUpperCase()}] **${goal.title}** (${goal.id}) — ${goal.priority} priority, owner: ${goalOwner}${nextAct}${linked}`;
         });
-        return textResult(`Goals (${goals.length}):\n${lines.join('\n')}`);
+        return textResult(`Goals (${entries.length}):\n${lines.join('\n')}`);
     });
     server.tool('goal_get', 'Get a single persistent goal with full history — progress notes, next actions, blockers, and linked cron jobs.', { id: z.string().describe('Goal ID') }, async ({ id }) => {
-        const filePath = path.join(GOALS_DIR, `${id}.json`);
-        if (!existsSync(filePath))
+        const goal = readGoalById(id);
+        if (!goal)
             return textResult(`Goal not found: ${id}`);
-        const goal = JSON.parse(readFileSync(filePath, 'utf-8'));
         const sections = [
             `# ${goal.title}`,
             `**ID:** ${goal.id} | **Status:** ${goal.status} | **Priority:** ${goal.priority} | **Owner:** ${goal.owner}`,
@@ -119,29 +107,28 @@ export function registerGoalTools(server) {
             `**Review:** ${goal.reviewFrequency}`,
             `\n## Description\n${goal.description}`,
         ];
-        if (goal.progressNotes?.length > 0)
-            sections.push(`\n## Progress Notes\n${goal.progressNotes.map((n) => `- ${n}`).join('\n')}`);
-        if (goal.nextActions?.length > 0)
-            sections.push(`\n## Next Actions\n${goal.nextActions.map((a) => `- [ ] ${a}`).join('\n')}`);
-        if (goal.blockers?.length > 0)
-            sections.push(`\n## Blockers\n${goal.blockers.map((b) => `- ${b}`).join('\n')}`);
-        if (goal.linkedCronJobs?.length > 0)
-            sections.push(`\n## Linked Cron Jobs\n${goal.linkedCronJobs.map((c) => `- ${c}`).join('\n')}`);
+        if (goal.progressNotes?.length)
+            sections.push(`\n## Progress Notes\n${goal.progressNotes.map(n => `- ${n}`).join('\n')}`);
+        if (goal.nextActions?.length)
+            sections.push(`\n## Next Actions\n${goal.nextActions.map(a => `- [ ] ${a}`).join('\n')}`);
+        if (goal.blockers?.length)
+            sections.push(`\n## Blockers\n${goal.blockers.map(b => `- ${b}`).join('\n')}`);
+        if (goal.linkedCronJobs?.length)
+            sections.push(`\n## Linked Cron Jobs\n${goal.linkedCronJobs.map(c => `- ${c}`).join('\n')}`);
         return textResult(sections.join('\n'));
     });
-    server.tool('goal_work', 'Spawn a focused background work session on a specific goal. The daemon picks up the trigger and runs a goal-directed session asynchronously — results are delivered via notifications.', {
+    server.tool('goal_work', 'Spawn a focused background work session on a specific goal. The daemon picks up the trigger and runs a goal-directed session as the goal\'s owner (so output lands in that agent\'s channel with that agent\'s tools). Results delivered via notifications.', {
         goal_id: z.string().describe('ID of the goal to work on'),
         focus: z.string().optional().describe('Specific aspect to focus on. Defaults to the goal\'s first nextAction.'),
         max_turns: z.number().optional().default(15).describe('Max agent turns for this work session'),
     }, async ({ goal_id, focus, max_turns }) => {
-        ensureGoalsDir();
-        const goalPath = path.join(GOALS_DIR, `${goal_id}.json`);
-        if (!existsSync(goalPath))
+        const goal = readGoalById(goal_id);
+        if (!goal)
             return textResult(`Goal not found: ${goal_id}. Use goal_list to see available goals.`);
-        const goal = JSON.parse(readFileSync(goalPath, 'utf-8'));
         if (goal.status !== 'active')
             return textResult(`Goal "${goal.title}" is ${goal.status} — only active goals can be worked on.`);
-        mkdirSync(GOAL_TRIGGER_DIR, { recursive: true });
+        if (!existsSync(GOAL_TRIGGER_DIR))
+            mkdirSync(GOAL_TRIGGER_DIR, { recursive: true });
         const trigger = {
             goalId: goal_id,
             focus: focus || goal.nextActions?.[0] || goal.description,
@@ -150,8 +137,9 @@ export function registerGoalTools(server) {
         };
         const triggerFile = path.join(GOAL_TRIGGER_DIR, `${Date.now()}-${goal_id}.trigger.json`);
         writeFileSync(triggerFile, JSON.stringify(trigger, null, 2));
-        logger.info({ goalId: goal_id, focus: trigger.focus }, 'Goal work session triggered');
+        logger.info({ goalId: goal_id, owner: goal.owner, focus: trigger.focus }, 'Goal work session triggered');
         return textResult(`Triggered goal work session for "${goal.title}" (${goal_id}).\n` +
+            `Owner: ${goal.owner}\n` +
             `Focus: ${trigger.focus}\n` +
             `The daemon will pick it up within a few seconds. Results delivered via notifications.`);
     });

package/dist/tools/session-tools.js

@@ -4,7 +4,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
-import { BASE_DIR, HANDOFFS_DIR, INBOX_DIR, TASKS_FILE, logger, textResult, todayStr, } from './shared.js';
+import { BASE_DIR, HANDOFFS_DIR, INBOX_DIR, TASKS_FILE, logger, textResult, todayStr, listAllGoals, } from './shared.js';
 function ensureHandoffsDir() {
     if (!existsSync(HANDOFFS_DIR))
         mkdirSync(HANDOFFS_DIR, { recursive: true });
@@ -66,26 +66,19 @@ export function registerSessionTools(server) {
     }, async ({ agent_slug, limit }) => {
         const maxItems = Math.min(limit ?? 10, 30);
         const items = [];
-        // 1. Stale goals
-        const goalsDir = path.join(BASE_DIR, 'goals');
-        if (existsSync(goalsDir)) {
-            for (const f of readdirSync(goalsDir).filter(f => f.endsWith('.json'))) {
-                try {
-                    const goal = JSON.parse(readFileSync(path.join(goalsDir, f), 'utf-8'));
-                    if (goal.status !== 'active')
-                        continue;
-                    if (agent_slug && goal.owner !== agent_slug)
-                        continue;
-                    const daysSinceUpdate = Math.floor((Date.now() - new Date(goal.updatedAt).getTime()) / 86400000);
-                    const staleThreshold = goal.reviewFrequency === 'daily' ? 1 : goal.reviewFrequency === 'weekly' ? 7 : 30;
-                    if (daysSinceUpdate > staleThreshold) {
-                        const urgency = Math.min(5, Math.floor(daysSinceUpdate / staleThreshold) + (goal.priority === 'high' ? 2 : goal.priority === 'medium' ? 1 : 0));
-                        items.push({ type: 'stale-goal', urgency, description: `Goal "${goal.title}" stale for ${daysSinceUpdate}d (${goal.priority} priority)` });
-                    }
-                }
-                catch {
-                    continue;
-                }
+        // 1. Stale goals (walks global + per-agent dirs)
+        for (const { goal, owner } of listAllGoals()) {
+            if (goal.status !== 'active')
+                continue;
+            if (agent_slug && owner !== agent_slug)
+                continue;
+            if (!goal.updatedAt)
+                continue;
+            const daysSinceUpdate = Math.floor((Date.now() - new Date(goal.updatedAt).getTime()) / 86400000);
+            const staleThreshold = goal.reviewFrequency === 'daily' ? 1 : goal.reviewFrequency === 'weekly' ? 7 : 30;
+            if (daysSinceUpdate > staleThreshold) {
+                const urgency = Math.min(5, Math.floor(daysSinceUpdate / staleThreshold) + (goal.priority === 'high' ? 2 : goal.priority === 'medium' ? 1 : 0));
+                items.push({ type: 'stale-goal', urgency, description: `Goal "${goal.title}" stale for ${daysSinceUpdate}d (${goal.priority} priority)` });
             }
         }
         // 2. Failing cron jobs

package/dist/tools/shared.d.ts

@@ -169,6 +169,46 @@ 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;
+export type GoalRecord = {
+    id: string;
+    title: string;
+    description?: string;
+    owner: string;
+    status?: string;
+    priority?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    progressNotes?: string[];
+    nextActions?: string[];
+    blockers?: string[];
+    reviewFrequency?: string;
+    linkedCronJobs?: string[];
+    [key: string]: unknown;
+};
+/** Return the directory where a goal owned by `owner` should live. */
+export declare function goalDirForOwner(owner: string): string;
+/**
+ * Walk Clementine's global goals dir AND every per-agent goals dir.
+ * Returns {goal, path, owner} for each goal found. Owner is derived from
+ * the goal's `owner` field if set, else inferred from which directory it was in.
+ */
+export declare function listAllGoals(): Array<{
+    goal: GoalRecord;
+    filePath: string;
+    owner: string;
+}>;
+/** Find a goal's file path by id across global + all agent dirs. */
+export declare function findGoalPath(id: string): {
+    filePath: string;
+    owner: string;
+} | null;
+/** Read a goal by id; returns null if not found. */
+export declare function readGoalById(id: string): GoalRecord | null;
+/**
+ * Write a goal to the correct directory based on its owner field.
+ * Creates the target directory if needed. Returns the path written.
+ */
+export declare function writeGoalForOwner(goal: GoalRecord): string;
 export declare function todayStr(): string;
 export declare function yesterdayStr(): string;
 export declare function nowTime(): string;

package/dist/tools/shared.js

@@ -96,6 +96,90 @@ export function agentDailyNotesDir(slug) {
         return DAILY_NOTES_DIR;
     return path.join(AGENTS_DIR, slug, 'daily-notes');
 }
+/** Return the directory where a goal owned by `owner` should live. */
+export function goalDirForOwner(owner) {
+    if (!owner || owner === 'clementine')
+        return GOALS_DIR;
+    return path.join(AGENTS_DIR, owner, 'goals');
+}
+/**
+ * Walk Clementine's global goals dir AND every per-agent goals dir.
+ * Returns {goal, path, owner} for each goal found. Owner is derived from
+ * the goal's `owner` field if set, else inferred from which directory it was in.
+ */
+export function listAllGoals() {
+    const results = [];
+    const readDir = (dir, inferredOwner) => {
+        if (!existsSync(dir))
+            return;
+        let files;
+        try {
+            files = readdirSync(dir).filter(f => f.endsWith('.json'));
+        }
+        catch {
+            return;
+        }
+        for (const f of files) {
+            const fp = path.join(dir, f);
+            try {
+                const goal = JSON.parse(readFileSync(fp, 'utf-8'));
+                if (!goal.id)
+                    continue;
+                const owner = (typeof goal.owner === 'string' && goal.owner) || inferredOwner;
+                results.push({ goal, filePath: fp, owner });
+            }
+            catch { /* skip malformed */ }
+        }
+    };
+    readDir(GOALS_DIR, 'clementine');
+    if (existsSync(AGENTS_DIR)) {
+        let agentDirs = [];
+        try {
+            agentDirs = readdirSync(AGENTS_DIR, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('_'))
+                .map(d => d.name);
+        }
+        catch { /* ignore */ }
+        for (const slug of agentDirs) {
+            readDir(path.join(AGENTS_DIR, slug, 'goals'), slug);
+        }
+    }
+    return results;
+}
+/** Find a goal's file path by id across global + all agent dirs. */
+export function findGoalPath(id) {
+    for (const entry of listAllGoals()) {
+        if (entry.goal.id === id) {
+            return { filePath: entry.filePath, owner: entry.owner };
+        }
+    }
+    return null;
+}
+/** Read a goal by id; returns null if not found. */
+export function readGoalById(id) {
+    const found = findGoalPath(id);
+    if (!found)
+        return null;
+    try {
+        return JSON.parse(readFileSync(found.filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write a goal to the correct directory based on its owner field.
+ * Creates the target directory if needed. Returns the path written.
+ */
+export function writeGoalForOwner(goal) {
+    const owner = goal.owner || 'clementine';
+    const dir = goalDirForOwner(owner);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const fp = path.join(dir, `${goal.id}.json`);
+    writeFileSync(fp, JSON.stringify(goal, null, 2));
+    return fp;
+}
 // ── Date/Time helpers ───────────────────────────────���──────────────────
 export function todayStr() {
     const d = new Date();

package/package.json

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