clementine-agent 1.0.11 → 1.0.12

package/dist/agent/assistant.js

@@ -13,11 +13,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { query as rawQuery, listSubagents, getSubagentMessages, } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, PROFILES_DIR, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, GOALS_DIR, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, ENABLE_1M_CONTEXT, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, } from '../config.js';
+import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, PROFILES_DIR, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, ENABLE_1M_CONTEXT, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, } from '../config.js';
 import { DEFAULT_CHANNEL_CAPABILITIES } from '../types.js';
 import { enforceToolPermissions, getSecurityPrompt, getHeartbeatSecurityPrompt, getCronSecurityPrompt, getHeartbeatDisallowedTools, logToolUse, setProfileTier, setProfileAllowedTools, setAgentDir, setSendPolicy, setInteractionSource, } from './hooks.js';
 import { scanner } from '../security/scanner.js';
-import { agentWorkingMemoryFile } from '../tools/shared.js';
+import { agentWorkingMemoryFile, listAllGoals } from '../tools/shared.js';
 import { AgentManager } from './agent-manager.js';
 import { extractLinks } from './link-extractor.js';
 import { StallGuard } from './stall-guard.js';
@@ -1491,17 +1491,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
         const goals = [];
         try {
-            if (!fs.existsSync(GOALS_DIR))
-                return goals;
-            for (const f of fs.readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'))) {
-                try {
-                    const goal = JSON.parse(fs.readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-                    if (goal.status === 'active')
-                        goals.push({ goal, file: f });
-                }
-                catch {
-                    continue;
-                }
+            for (const { goal, filePath } of listAllGoals()) {
+                if (goal.status === 'active')
+                    goals.push({ goal, file: path.basename(filePath) });
             }
         }
         catch { /* non-fatal */ }
@@ -3039,15 +3031,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // ── Goal context: inject linked goal info ───────────────────────
         let goalContext = '';
         try {
-            if (fs.existsSync(GOALS_DIR)) {
-                const goalFiles = fs.readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
-                const linkedGoals = goalFiles
-                    .map(f => { try {
-                    return JSON.parse(fs.readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-                }
-                catch {
-                    return null;
-                } })
+            {
+                const linkedGoals = listAllGoals()
+                    .map(({ goal }) => goal)
                     .filter(g => g && g.status === 'active' && g.linkedCronJobs?.includes(jobName));
                 if (linkedGoals.length > 0) {
                     const goalLines = linkedGoals.map((g) => {

package/dist/agent/daily-planner.js

@@ -8,7 +8,8 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, GOALS_DIR, CRON_REFLECTIONS_DIR, TASKS_FILE, INBOX_DIR, MODELS, } from '../config.js';
+import { BASE_DIR, CRON_REFLECTIONS_DIR, TASKS_FILE, INBOX_DIR, MODELS, } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.daily-planner' });
 const PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
 // ── Helpers ──────────────────────────────────────────────────────────
@@ -95,21 +96,10 @@ export class DailyPlanner {
         return sections.join('\n\n') || 'No context available — all clear.';
     }
     loadActiveGoals() {
-        if (!existsSync(GOALS_DIR))
-            return [];
         try {
-            const files = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
-            const goals = [];
-            for (const f of files) {
-                try {
-                    const goal = JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-                    if (goal.status === 'active')
-                        goals.push(goal);
-                }
-                catch {
-                    continue;
-                }
-            }
+            const goals = listAllGoals()
+                .map(({ goal }) => goal)
+                .filter(g => g && g.status === 'active');
             return goals.sort((a, b) => {
                 const p = { high: 0, medium: 1, low: 2 };
                 return (p[a.priority] ?? 2) - (p[b.priority] ?? 2);

package/dist/agent/insight-engine.js

@@ -12,6 +12,7 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
 import { GOALS_DIR, BASE_DIR } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.insight-engine' });
 const BASE_COOLDOWN_MS = 2 * 60 * 60 * 1000; // 2 hours
 const MAX_DAILY_INSIGHTS = 3;
@@ -133,20 +134,9 @@ export function gatherInsightSignals(gateway) {
         if (sessionCount === 0) {
             // No recent activity — could note quiet period if there are pending goals
             try {
-                if (existsSync(GOALS_DIR)) {
-                    const goals = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
-                    const activeHighPriority = goals.filter(f => {
-                        try {
-                            const g = JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-                            return g.status === 'active' && g.priority === 'high';
-                        }
-                        catch {
-                            return false;
-                        }
-                    });
-                    if (activeHighPriority.length > 0) {
-                        signals.push(`Quiet period: ${activeHighPriority.length} high-priority goal(s) active but no recent user interaction`);
-                    }
+                const activeHighPriority = listAllGoals().filter(({ goal }) => goal.status === 'active' && goal.priority === 'high');
+                if (activeHighPriority.length > 0) {
+                    signals.push(`Quiet period: ${activeHighPriority.length} high-priority goal(s) active but no recent user interaction`);
                 }
             }
             catch { /* non-fatal */ }

package/dist/agent/prompt-evolver.js

@@ -5,10 +5,11 @@
  * reflections, progress state, and goal context. Returns the enrichment
  * string to be appended to the original prompt.
  */
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, CRON_REFLECTIONS_DIR, CRON_PROGRESS_DIR, GOALS_DIR } from '../config.js';
+import { BASE_DIR, CRON_REFLECTIONS_DIR, CRON_PROGRESS_DIR } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.prompt-evolver' });
 /**
  * Evolve a static cron prompt by enriching it with lessons from reflections,
@@ -225,22 +226,13 @@ function extractProgressInsights(jobName) {
  * Find goals that reference this cron job and inject alignment guidance.
  */
 function extractGoalGuidance(jobName) {
-    if (!existsSync(GOALS_DIR))
-        return null;
     try {
-        const files = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
         const linkedGoals = [];
-        for (const f of files) {
-            try {
-                const goal = JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-                if (goal.status !== 'active')
-                    continue;
-                if (goal.linkedCronJobs?.includes(jobName)) {
-                    linkedGoals.push(goal);
-                }
-            }
-            catch {
+        for (const { goal } of listAllGoals()) {
+            if (goal.status !== 'active')
                 continue;
+            if (goal.linkedCronJobs?.includes(jobName)) {
+                linkedGoals.push(goal);
             }
         }
         if (linkedGoals.length === 0)

package/dist/agent/self-improve.js

@@ -14,6 +14,7 @@ import matter from 'gray-matter';
 import path from 'node:path';
 import pino from 'pino';
 import { BASE_DIR, SELF_IMPROVE_DIR, SOUL_FILE, AGENTS_FILE, CRON_FILE, WORKFLOWS_DIR, VAULT_DIR, MEMORY_DB_PATH, AGENTS_DIR, PKG_DIR, CRON_REFLECTIONS_DIR, GOALS_DIR, } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.self-improve' });
 // ── Defaults ─────────────────────────────────────────────────────────
 const DEFAULT_CONFIG = {
@@ -481,34 +482,27 @@ export class SelfImproveLoop {
             }
         }
         catch { /* non-fatal */ }
-        // Gather goal health data
+        // Gather goal health data (walks global + per-agent goals dirs)
         const goalHealth = [];
         try {
-            if (existsSync(GOALS_DIR)) {
-                const goalFiles = readdirSync(GOALS_DIR).filter(f => f.endsWith('.json'));
-                const now = Date.now();
-                const DAY_MS = 86_400_000;
-                for (const file of goalFiles) {
-                    try {
-                        const goal = JSON.parse(readFileSync(path.join(GOALS_DIR, file), 'utf-8'));
-                        const lastUpdate = goal.updatedAt ? new Date(goal.updatedAt).getTime() : 0;
-                        const daysSinceUpdate = Math.floor((now - lastUpdate) / DAY_MS);
-                        const staleThreshold = goal.reviewFrequency === 'daily' ? 1 : goal.reviewFrequency === 'weekly' ? 7 : 30;
-                        goalHealth.push({
-                            id: goal.id,
-                            title: goal.title,
-                            status: goal.status,
-                            owner: goal.owner,
-                            priority: goal.priority,
-                            daysSinceUpdate,
-                            reviewFrequency: goal.reviewFrequency,
-                            isStale: goal.status === 'active' && daysSinceUpdate > staleThreshold,
-                            linkedCronJobs: goal.linkedCronJobs || [],
-                            progressCount: goal.progressNotes?.length ?? 0,
-                        });
-                    }
-                    catch { /* skip malformed */ }
-                }
+            const now = Date.now();
+            const DAY_MS = 86_400_000;
+            for (const { goal, owner } of listAllGoals()) {
+                const lastUpdate = goal.updatedAt ? new Date(goal.updatedAt).getTime() : 0;
+                const daysSinceUpdate = Math.floor((now - lastUpdate) / DAY_MS);
+                const staleThreshold = goal.reviewFrequency === 'daily' ? 1 : goal.reviewFrequency === 'weekly' ? 7 : 30;
+                goalHealth.push({
+                    id: goal.id,
+                    title: goal.title,
+                    status: goal.status,
+                    owner: owner,
+                    priority: goal.priority,
+                    daysSinceUpdate,
+                    reviewFrequency: goal.reviewFrequency,
+                    isStale: goal.status === 'active' && daysSinceUpdate > staleThreshold,
+                    linkedCronJobs: goal.linkedCronJobs || [],
+                    progressCount: goal.progressNotes?.length ?? 0,
+                });
             }
         }
         catch { /* non-fatal */ }

package/dist/agent/strategic-planner.js

@@ -13,6 +13,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import path from 'node:path';
 import pino from 'pino';
 import { BASE_DIR, GOALS_DIR, MODELS } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.strategic-planner' });
 const DAILY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
 const WEEKLY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'weekly');
@@ -265,34 +266,12 @@ export class StrategicPlanner {
         }).filter(Boolean);
     }
     loadActiveGoals() {
-        if (!existsSync(GOALS_DIR))
-            return [];
-        return readdirSync(GOALS_DIR)
-            .filter(f => f.endsWith('.json'))
-            .map(f => {
-            try {
-                return JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((g) => g && g.status === 'active');
+        return listAllGoals()
+            .map(({ goal }) => goal)
+            .filter(g => g && g.status === 'active');
     }
     loadAllGoals() {
-        if (!existsSync(GOALS_DIR))
-            return [];
-        return readdirSync(GOALS_DIR)
-            .filter(f => f.endsWith('.json'))
-            .map(f => {
-            try {
-                return JSON.parse(readFileSync(path.join(GOALS_DIR, f), 'utf-8'));
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter(Boolean);
+        return listAllGoals().map(({ goal }) => goal);
     }
 }
 // ── Date helpers ───────────────────────────────────────────────────────

package/dist/agent/team-bus.js

@@ -5,10 +5,10 @@
  * Logs to JSONL and optionally mirrors to a Discord channel.
  */
 import { createHash, randomBytes } from 'node:crypto';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import os from 'node:os';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
+import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.team-bus' });
 /** Max inter-agent message depth before rejection (anti-loop). */
 const MAX_DEPTH = 3;
@@ -247,19 +247,10 @@ export class TeamBus {
     }
     /** Broadcast a message to all team agents (optionally scoped to a goal). */
     async broadcast(fromSlug, content, goalId, _sessionKey) {
-        const goalsDir = path.join(process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine'), 'goals');
         let targetSlugs = [];
-        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.id === goalId && goal.owner && goal.owner !== fromSlug) {
-                        targetSlugs.push(goal.owner);
-                    }
-                }
-                catch {
-                    continue;
-                }
+        for (const { goal, owner } of listAllGoals()) {
+            if (goal.id === goalId && owner && owner !== fromSlug) {
+                targetSlugs.push(owner);
             }
         }
         const allAgents = this.teamRouter.listTeamAgents();

package/dist/cli/dashboard.js

@@ -5684,15 +5684,14 @@ export async function cmdDashboard(opts) {
         res.json(analytics);
     });
     // ── Goals, Delegations, Workflows, Digest — extracted routers ──
-    const GOALS_DIR = path.join(BASE_DIR, 'goals');
     const CRON_RUNS_DIR = path.join(BASE_DIR, 'cron', 'runs');
     const AGENTS_BASE = path.join(VAULT_DIR, '00-System', 'agents');
     const WORKFLOWS_DIR = path.join(VAULT_DIR, '00-System', 'workflows');
     const WORKFLOW_RUNS_DIR = path.join(BASE_DIR, 'workflows', 'runs');
-    app.use('/api/goals', goalsRouter({ goalsDir: GOALS_DIR, cronRunsDir: CRON_RUNS_DIR, vaultDir: VAULT_DIR, cronFile: CRON_FILE, getGateway }));
+    app.use('/api/goals', goalsRouter({ cronRunsDir: CRON_RUNS_DIR, vaultDir: VAULT_DIR, cronFile: CRON_FILE, getGateway }));
     app.use('/api/delegations', delegationsRouter({ agentsBase: AGENTS_BASE, getGateway, broadcastEvent }));
     app.use('/api/workflows', workflowsRouter({ workflowsDir: WORKFLOWS_DIR, workflowRunsDir: WORKFLOW_RUNS_DIR, agentsBase: AGENTS_BASE, getGateway, broadcastEvent, cachedAsync }));
-    app.use('/api/digest', digestRouter({ baseDir: BASE_DIR, vaultDir: VAULT_DIR, goalsDir: GOALS_DIR, memoryDbPath: MEMORY_DB_PATH, parseEnvFile, getGateway, cached }));
+    app.use('/api/digest', digestRouter({ baseDir: BASE_DIR, vaultDir: VAULT_DIR, memoryDbPath: MEMORY_DB_PATH, parseEnvFile, getGateway, cached }));
     // Voice audio route (served from digest router but needs top-level mount for /api/voice/ path)
     app.get('/api/voice/audio/:hash', (req, res) => {
         const hash = req.params.hash.replace(/[^a-f0-9]/g, '');

package/dist/cli/routes/digest.d.ts

@@ -6,7 +6,6 @@ import type { Gateway } from '../../gateway/router.js';
 export interface DigestRouterDeps {
     baseDir: string;
     vaultDir: string;
-    goalsDir: string;
     memoryDbPath: string;
     parseEnvFile: () => Record<string, string>;
     getGateway: () => Promise<Gateway>;

package/dist/cli/routes/digest.js

@@ -7,6 +7,7 @@ import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, } from
 import { randomBytes } from 'node:crypto';
 import path from 'node:path';
 import matter from 'gray-matter';
+import { listAllGoals } from '../../tools/shared.js';
 export function getDigestPrefs(prefsFile) {
     const defaults = {
         enabled: false,
@@ -27,7 +28,7 @@ export function getDigestPrefs(prefsFile) {
 }
 export function digestRouter(deps) {
     const router = Router();
-    const { baseDir, vaultDir, goalsDir, memoryDbPath, parseEnvFile, getGateway, cached } = deps;
+    const { baseDir, vaultDir, memoryDbPath, parseEnvFile, getGateway, cached } = deps;
     const prefsFile = path.join(baseDir, 'digest-preferences.json');
     const voiceCacheDir = path.join(baseDir, 'cache', 'voice');
     // Graph API helper for email
@@ -101,16 +102,10 @@ export function digestRouter(deps) {
         }
         if (secs.goals !== false) {
             try {
-                if (existsSync(goalsDir)) {
-                    const files = readdirSync(goalsDir).filter(f => f.endsWith('.json'));
-                    const goals = files.map(f => { try {
-                        return JSON.parse(readFileSync(path.join(goalsDir, f), 'utf-8'));
-                    }
-                    catch {
-                        return null;
-                    } }).filter(Boolean);
-                    const active = goals.filter((g) => g.status === 'active');
-                    const blocked = goals.filter((g) => g.status === 'blocked');
+                {
+                    const goals = listAllGoals().map(e => e.goal);
+                    const active = goals.filter(g => g.status === 'active');
+                    const blocked = goals.filter(g => g.status === 'blocked');
                     let goalText = `${active.length} active, ${blocked.length} blocked\n`;
                     active.slice(0, 5).forEach((g) => {
                         goalText += `  - ${g.title} [${g.priority}]`;

package/dist/cli/routes/goals.d.ts

@@ -1,10 +1,13 @@
 /**
- * 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 type { Gateway } from '../../gateway/router.js';
 export interface GoalsRouterDeps {
-    goalsDir: string;
     cronRunsDir: string;
     vaultDir: string;
     cronFile: string;

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;

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.12",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",