clementine-agent 1.0.11 → 1.0.13

package/dist/agent/agent-manager.js

@@ -14,8 +14,10 @@ import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import matter from 'gray-matter';
+import { randomBytes } from 'node:crypto';
 import { ProfileManager } from './profiles.js';
 import { getScaffoldForRole } from './role-scaffolds.js';
+import { writeGoalForOwner } from '../tools/shared.js';
 // ── Keychain helpers for agent secrets ────────────────────────────────
 function storeAgentSecret(slug, key, value) {
     execSync(`security add-generic-password -U -s "clementine" -a "AGENT_${slug.toUpperCase()}_${key}" -w "${value}"`, { stdio: 'pipe', timeout: 3000 });
@@ -324,6 +326,36 @@ export class AgentManager {
                 }
             }
         }
+        // Seed a starter goal so the agent shows up in goal reviews from day one.
+        // Status is "pending" — forces the owner to give it a real success metric
+        // before it starts driving goal_work sessions.
+        try {
+            const now = new Date().toISOString();
+            const starterGoal = {
+                id: randomBytes(4).toString('hex'),
+                title: `${config.name}: Define Success Metric`,
+                description: `Starter goal auto-created when ${config.name} was hired. Replace this with a ` +
+                    `concrete outcome and measurable success metric (e.g., "book 3 demos/week", ` +
+                    `"publish 2 posts/week", "reduce queue backlog under 50 items"). Set status to ` +
+                    `"active" once defined so goal_work sessions can drive progress.`,
+                status: 'pending',
+                owner: slug,
+                priority: 'high',
+                createdAt: now,
+                updatedAt: now,
+                progressNotes: [],
+                nextActions: [
+                    `Define the measurable success metric for ${config.name}`,
+                    'Link the relevant cron jobs once the metric is set',
+                    'Set status to "active" to enable goal_work sessions',
+                ],
+                blockers: ['Success metric not yet defined'],
+                reviewFrequency: 'weekly',
+                linkedCronJobs: [],
+            };
+            writeGoalForOwner(starterGoal);
+        }
+        catch { /* non-fatal — agent is still created */ }
         // Invalidate cache
         this.cacheTime = 0;
         return this.get(slug);

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;