clementine-agent 1.0.77 → 1.0.79

package/dist/gateway/agent-heartbeat-manager.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Owns the lifecycle of all per-agent heartbeat schedulers.
+ *
+ * Boots at daemon start, scans the AgentManager's active list, spawns one
+ * AgentHeartbeatScheduler per agent. An outer 60s interval iterates the
+ * registry and fires `tick()` on any agent whose nextCheckAt is due.
+ *
+ * Reconciliation runs each outer tick: agents added to AGENTS_DIR start
+ * heartbeats automatically; agents removed (or paused/terminated) drop
+ * out. Per-agent failures are caught so one buggy agent can't crash the
+ * daemon or stall others.
+ */
+import type { AgentManager } from '../agent/agent-manager.js';
+import { AgentHeartbeatScheduler, type AgentHeartbeatGateway } from './agent-heartbeat-scheduler.js';
+export declare class AgentHeartbeatManager {
+    private readonly agentManager;
+    private readonly gateway;
+    private readonly schedulers;
+    private timer;
+    private running;
+    private ticking;
+    constructor(agentManager: AgentManager, gateway?: AgentHeartbeatGateway);
+    start(): void;
+    stop(): void;
+    /** Add/remove schedulers to match the current AgentManager listing. */
+    private reconcile;
+    /**
+     * One outer-loop tick. Reconcile the registry, then fire agents whose
+     * nextCheckAt has come due. Runs serially to avoid races on shared
+     * state (goals dir, cron runs dir).
+     */
+    private outerTick;
+    /** Diagnostic helper for the dashboard / CLI. */
+    getStatus(): Array<{
+        slug: string;
+        nextCheckAt: string;
+        lastTickAt: string;
+        silentTickCount: number;
+    }>;
+    /** Look up a scheduler — useful for CLI commands like "tick this agent now." */
+    getScheduler(slug: string): AgentHeartbeatScheduler | null;
+}
+//# sourceMappingURL=agent-heartbeat-manager.d.ts.map

package/dist/gateway/agent-heartbeat-manager.js

@@ -0,0 +1,125 @@
+/**
+ * Owns the lifecycle of all per-agent heartbeat schedulers.
+ *
+ * Boots at daemon start, scans the AgentManager's active list, spawns one
+ * AgentHeartbeatScheduler per agent. An outer 60s interval iterates the
+ * registry and fires `tick()` on any agent whose nextCheckAt is due.
+ *
+ * Reconciliation runs each outer tick: agents added to AGENTS_DIR start
+ * heartbeats automatically; agents removed (or paused/terminated) drop
+ * out. Per-agent failures are caught so one buggy agent can't crash the
+ * daemon or stall others.
+ */
+import pino from 'pino';
+import { AgentHeartbeatScheduler } from './agent-heartbeat-scheduler.js';
+const logger = pino({ name: 'clementine.agent-heartbeat-manager' });
+const OUTER_TICK_MS = 60_000;
+export class AgentHeartbeatManager {
+    agentManager;
+    gateway;
+    schedulers = new Map();
+    timer = null;
+    running = false;
+    ticking = false;
+    constructor(agentManager, gateway) {
+        this.agentManager = agentManager;
+        this.gateway = gateway ?? null;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.reconcile();
+        // Run an immediate tick so schedulers boot up without a 60s delay.
+        this.outerTick().catch((err) => logger.error({ err }, 'Initial agent heartbeat tick failed'));
+        this.timer = setInterval(() => {
+            this.outerTick().catch((err) => logger.error({ err }, 'Agent heartbeat outer tick failed'));
+        }, OUTER_TICK_MS);
+        logger.info({ agents: this.schedulers.size }, 'Agent heartbeat manager started');
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.schedulers.clear();
+        logger.info('Agent heartbeat manager stopped');
+    }
+    /** Add/remove schedulers to match the current AgentManager listing. */
+    reconcile() {
+        let active = [];
+        try {
+            active = this.agentManager
+                .listAll()
+                .filter((p) => p.slug !== 'clementine' && this.agentManager.isRunnable(p.slug))
+                .map((p) => p.slug);
+        }
+        catch (err) {
+            logger.warn({ err }, 'Failed to list agents during reconcile — keeping current set');
+            return;
+        }
+        const activeSet = new Set(active);
+        // Add new
+        for (const slug of active) {
+            if (!this.schedulers.has(slug)) {
+                this.schedulers.set(slug, new AgentHeartbeatScheduler(slug, this.agentManager, this.gateway ? { gateway: this.gateway } : {}));
+                logger.info({ slug }, 'Agent heartbeat: registered scheduler');
+            }
+        }
+        // Remove gone-or-paused
+        for (const slug of [...this.schedulers.keys()]) {
+            if (!activeSet.has(slug)) {
+                this.schedulers.delete(slug);
+                logger.info({ slug }, 'Agent heartbeat: deregistered scheduler');
+            }
+        }
+    }
+    /**
+     * One outer-loop tick. Reconcile the registry, then fire agents whose
+     * nextCheckAt has come due. Runs serially to avoid races on shared
+     * state (goals dir, cron runs dir).
+     */
+    async outerTick(now = new Date()) {
+        if (this.ticking)
+            return; // prior outer tick still in flight — skip
+        this.ticking = true;
+        try {
+            this.reconcile();
+            for (const [slug, scheduler] of this.schedulers) {
+                try {
+                    if (!scheduler.isDue(now))
+                        continue;
+                    await scheduler.tick(now);
+                }
+                catch (err) {
+                    logger.warn({ err, slug }, 'Agent heartbeat tick failed — continuing');
+                }
+            }
+        }
+        finally {
+            this.ticking = false;
+        }
+    }
+    /** Diagnostic helper for the dashboard / CLI. */
+    getStatus() {
+        const out = [];
+        for (const [slug, scheduler] of this.schedulers) {
+            const state = scheduler.loadState();
+            out.push({
+                slug,
+                nextCheckAt: state.nextCheckAt,
+                lastTickAt: state.lastTickAt,
+                silentTickCount: state.silentTickCount,
+            });
+        }
+        return out;
+    }
+    /** Look up a scheduler — useful for CLI commands like "tick this agent now." */
+    getScheduler(slug) {
+        return this.schedulers.get(slug) ?? null;
+    }
+}
+//# sourceMappingURL=agent-heartbeat-manager.js.map

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

@@ -0,0 +1,78 @@
+/**
+ * Per-agent heartbeat scheduler — one instance per specialist agent
+ * (Ross, Sasha, Nora, etc.). Runs autonomously alongside Clementine's
+ * own HeartbeatScheduler.
+ *
+ * Phase 2 — cheap path only. No LLM call. The tick loads state, scans
+ * three signals (pending delegated tasks, recent goal updates, recent
+ * cron completions), updates fingerprint, and persists state.
+ *
+ * Phase 3 will add the LLM-path tick (assistant.heartbeat() with the
+ * agent's profile) when the fingerprint indicates a real signal change.
+ */
+import type { AgentHeartbeatState } from '../types.js';
+import type { AgentManager } from '../agent/agent-manager.js';
+/**
+ * Minimal gateway surface the scheduler needs for the LLM tick path.
+ * Kept narrow so tests can mock it without pulling in the full Gateway.
+ */
+export interface AgentHeartbeatGateway {
+    handleCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, mode?: 'standard' | 'unleashed', maxHours?: number, timeoutMs?: number, successCriteria?: string[], agentSlug?: string): Promise<string>;
+}
+export interface AgentHeartbeatOptions {
+    /** Override the base directory for test isolation. Defaults to config.BASE_DIR. */
+    baseDir?: string;
+    /** Override the agents directory for test isolation. Defaults to config.AGENTS_DIR. */
+    agentsDir?: string;
+    /**
+     * Gateway used for the LLM tick path. When omitted, the scheduler runs in
+     * cheap-path-only mode (observation + logging, no LLM call). Tests pass
+     * mocks here; production passes the real Gateway.
+     */
+    gateway?: AgentHeartbeatGateway;
+}
+export declare class AgentHeartbeatScheduler {
+    private readonly slug;
+    private readonly agentManager;
+    private readonly baseDir;
+    private readonly agentsDir;
+    private readonly stateFile;
+    private readonly gateway;
+    constructor(slug: string, agentManager: AgentManager, opts?: AgentHeartbeatOptions);
+    /** Read persisted state, or return a fresh state ready to tick now. */
+    loadState(): AgentHeartbeatState;
+    saveState(state: AgentHeartbeatState): void;
+    /** True if the agent is due for a tick. */
+    isDue(now?: Date): boolean;
+    /**
+     * Compute a cheap fingerprint of "anything material to this agent."
+     * Three signals: pending delegated tasks, latest goal update, latest
+     * cron run timestamp. Sync filesystem reads — bounded and small.
+     */
+    private buildFingerprint;
+    /**
+     * Tick. Loads state, builds fingerprint, decides whether to invoke the
+     * LLM path, persists the new state. The LLM call is only made when:
+     *
+     *   1. The fingerprint changed (something material moved since last tick), AND
+     *   2. The prior fingerprint was non-empty (we don't fire LLM on the very
+     *      first tick after daemon start — those are noisy and not signal), AND
+     *   3. A gateway is wired (opts.gateway). Tests run cheap-path-only.
+     */
+    tick(now?: Date): Promise<AgentHeartbeatState>;
+    /**
+     * Build and dispatch the LLM tick prompt via gateway.handleCronJob.
+     * Output already routes to the agent's Discord channel (dispatcher.send
+     * is called inside the cron path with the agentSlug).
+     */
+    private runLlmTick;
+    /** Parse `[NEXT_CHECK: Xm]` directive from the agent's output. Public for tests. */
+    static parseLlmTickOutput(output: string): {
+        nextCheckMinutes: number | undefined;
+        summary: string;
+    };
+    /** Schedule the next check explicitly. Clamped to [MIN, MAX] minutes. */
+    setNextCheckIn(minutes: number, now?: Date): void;
+    getSlug(): string;
+}
+//# sourceMappingURL=agent-heartbeat-scheduler.d.ts.map

package/dist/gateway/agent-heartbeat-scheduler.js

@@ -0,0 +1,293 @@
+/**
+ * Per-agent heartbeat scheduler — one instance per specialist agent
+ * (Ross, Sasha, Nora, etc.). Runs autonomously alongside Clementine's
+ * own HeartbeatScheduler.
+ *
+ * Phase 2 — cheap path only. No LLM call. The tick loads state, scans
+ * three signals (pending delegated tasks, recent goal updates, recent
+ * cron completions), updates fingerprint, and persists state.
+ *
+ * Phase 3 will add the LLM-path tick (assistant.heartbeat() with the
+ * agent's profile) when the fingerprint indicates a real signal change.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { AGENTS_DIR, BASE_DIR } from '../config.js';
+import { listAllGoals } from '../tools/shared.js';
+const logger = pino({ name: 'clementine.agent-heartbeat' });
+const DEFAULT_INTERVAL_MIN = 30;
+const MIN_INTERVAL_MIN = 5;
+const MAX_INTERVAL_MIN = 12 * 60;
+export class AgentHeartbeatScheduler {
+    slug;
+    agentManager;
+    baseDir;
+    agentsDir;
+    stateFile;
+    gateway;
+    constructor(slug, agentManager, opts = {}) {
+        this.slug = slug;
+        this.agentManager = agentManager;
+        this.baseDir = opts.baseDir ?? BASE_DIR;
+        this.agentsDir = opts.agentsDir ?? AGENTS_DIR;
+        this.stateFile = path.join(this.baseDir, 'heartbeat', 'agents', slug, 'state.json');
+        this.gateway = opts.gateway ?? null;
+    }
+    /** Read persisted state, or return a fresh state ready to tick now. */
+    loadState() {
+        try {
+            if (existsSync(this.stateFile)) {
+                const raw = JSON.parse(readFileSync(this.stateFile, 'utf-8'));
+                return {
+                    slug: this.slug,
+                    lastTickAt: String(raw.lastTickAt ?? ''),
+                    nextCheckAt: String(raw.nextCheckAt ?? new Date().toISOString()),
+                    silentTickCount: Number(raw.silentTickCount ?? 0),
+                    fingerprint: String(raw.fingerprint ?? ''),
+                    ...(raw.lastSignalSummary ? { lastSignalSummary: raw.lastSignalSummary } : {}),
+                };
+            }
+        }
+        catch (err) {
+            logger.warn({ err, slug: this.slug }, 'Failed to load agent heartbeat state — starting fresh');
+        }
+        return {
+            slug: this.slug,
+            lastTickAt: '',
+            nextCheckAt: new Date().toISOString(),
+            silentTickCount: 0,
+            fingerprint: '',
+        };
+    }
+    saveState(state) {
+        try {
+            mkdirSync(path.dirname(this.stateFile), { recursive: true });
+            writeFileSync(this.stateFile, JSON.stringify(state, null, 2));
+        }
+        catch (err) {
+            logger.warn({ err, slug: this.slug }, 'Failed to save agent heartbeat state — non-fatal');
+        }
+    }
+    /** True if the agent is due for a tick. */
+    isDue(now = new Date()) {
+        const state = this.loadState();
+        if (!state.nextCheckAt)
+            return true;
+        return new Date(state.nextCheckAt).getTime() <= now.getTime();
+    }
+    /**
+     * Compute a cheap fingerprint of "anything material to this agent."
+     * Three signals: pending delegated tasks, latest goal update, latest
+     * cron run timestamp. Sync filesystem reads — bounded and small.
+     */
+    buildFingerprint() {
+        const signals = { slug: this.slug };
+        // 1. Pending delegated task count
+        try {
+            const tasksDir = path.join(this.agentsDir, this.slug, 'tasks');
+            if (existsSync(tasksDir)) {
+                const files = readdirSync(tasksDir).filter((f) => f.endsWith('.json'));
+                let pendingCount = 0;
+                for (const file of files) {
+                    try {
+                        const task = JSON.parse(readFileSync(path.join(tasksDir, file), 'utf-8'));
+                        if (task && task.status === 'pending')
+                            pendingCount++;
+                    }
+                    catch { /* skip malformed */ }
+                }
+                signals.pendingTasks = pendingCount;
+            }
+            else {
+                signals.pendingTasks = 0;
+            }
+        }
+        catch {
+            signals.pendingTasks = 0;
+        }
+        // 2. Latest goal updatedAt for this agent's goals
+        try {
+            let latest = '';
+            for (const { goal, owner } of listAllGoals()) {
+                if (owner !== this.slug)
+                    continue;
+                const updatedAt = goal.updatedAt ?? '';
+                if (updatedAt > latest)
+                    latest = updatedAt;
+            }
+            signals.latestGoalUpdate = latest;
+        }
+        catch {
+            signals.latestGoalUpdate = '';
+        }
+        // 3. Latest cron run for any of this agent's crons (file mtime is enough)
+        try {
+            const runsDir = path.join(this.baseDir, 'cron', 'runs');
+            let latestMs = 0;
+            if (existsSync(runsDir)) {
+                const prefix = `${this.slug}:`;
+                for (const file of readdirSync(runsDir)) {
+                    if (!file.endsWith('.jsonl'))
+                        continue;
+                    if (!file.startsWith(prefix) && !file.startsWith(this.slug + '_'))
+                        continue;
+                    try {
+                        const mtime = statSync(path.join(runsDir, file)).mtimeMs;
+                        if (mtime > latestMs)
+                            latestMs = mtime;
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            signals.latestCronRunMs = latestMs;
+        }
+        catch {
+            signals.latestCronRunMs = 0;
+        }
+        const fingerprint = createHash('sha1')
+            .update(JSON.stringify(signals))
+            .digest('hex')
+            .slice(0, 16);
+        return { fingerprint, signals };
+    }
+    /**
+     * Tick. Loads state, builds fingerprint, decides whether to invoke the
+     * LLM path, persists the new state. The LLM call is only made when:
+     *
+     *   1. The fingerprint changed (something material moved since last tick), AND
+     *   2. The prior fingerprint was non-empty (we don't fire LLM on the very
+     *      first tick after daemon start — those are noisy and not signal), AND
+     *   3. A gateway is wired (opts.gateway). Tests run cheap-path-only.
+     */
+    async tick(now = new Date()) {
+        const profile = this.agentManager.get(this.slug);
+        if (!profile) {
+            // Agent was removed mid-flight — return a state that won't tick again soon.
+            return {
+                slug: this.slug,
+                lastTickAt: now.toISOString(),
+                nextCheckAt: new Date(now.getTime() + MAX_INTERVAL_MIN * 60_000).toISOString(),
+                silentTickCount: 0,
+                fingerprint: '',
+                lastSignalSummary: 'agent profile not found',
+            };
+        }
+        if (!this.agentManager.isRunnable(this.slug)) {
+            logger.debug({ slug: this.slug, status: profile.status }, 'Agent not runnable — skipping tick');
+            const next = new Date(now.getTime() + DEFAULT_INTERVAL_MIN * 60_000);
+            const prior = this.loadState();
+            const state = {
+                ...prior,
+                slug: this.slug,
+                lastTickAt: now.toISOString(),
+                nextCheckAt: next.toISOString(),
+            };
+            this.saveState(state);
+            return state;
+        }
+        const prior = this.loadState();
+        const { fingerprint, signals } = this.buildFingerprint();
+        const changed = fingerprint !== prior.fingerprint;
+        let nextCheckMinutes = DEFAULT_INTERVAL_MIN;
+        let lastSignalSummary;
+        const shouldRunLlm = changed && prior.fingerprint !== '' && this.gateway !== null;
+        if (shouldRunLlm) {
+            try {
+                const result = await this.runLlmTick(profile, signals, prior, now);
+                nextCheckMinutes = result.nextCheckMinutes ?? DEFAULT_INTERVAL_MIN;
+                lastSignalSummary = result.summary?.slice(0, 240);
+            }
+            catch (err) {
+                logger.warn({ err, slug: this.slug }, 'Agent LLM tick failed — using default cadence');
+                lastSignalSummary = `llm tick error: ${String(err).slice(0, 200)}`;
+            }
+        }
+        else if (changed) {
+            lastSignalSummary = `signal change: ${JSON.stringify(signals)}`.slice(0, 240);
+        }
+        else {
+            lastSignalSummary = prior.lastSignalSummary;
+        }
+        const clampedMin = Math.max(MIN_INTERVAL_MIN, Math.min(MAX_INTERVAL_MIN, Math.floor(nextCheckMinutes)));
+        const next = new Date(now.getTime() + clampedMin * 60_000);
+        const state = {
+            slug: this.slug,
+            lastTickAt: now.toISOString(),
+            nextCheckAt: next.toISOString(),
+            silentTickCount: changed ? 0 : prior.silentTickCount + 1,
+            fingerprint,
+            ...(lastSignalSummary ? { lastSignalSummary } : {}),
+        };
+        this.saveState(state);
+        if (changed) {
+            logger.info({ slug: this.slug, signals, fingerprint, ranLlm: shouldRunLlm, nextCheckMin: clampedMin }, 'Agent heartbeat tick');
+        }
+        else {
+            logger.debug({ slug: this.slug, silentTicks: state.silentTickCount }, 'Agent heartbeat: silent tick');
+        }
+        return state;
+    }
+    /**
+     * Build and dispatch the LLM tick prompt via gateway.handleCronJob.
+     * Output already routes to the agent's Discord channel (dispatcher.send
+     * is called inside the cron path with the agentSlug).
+     */
+    async runLlmTick(profile, signals, prior, now) {
+        if (!this.gateway) {
+            return { nextCheckMinutes: undefined, summary: '' };
+        }
+        const sinceLastMin = prior.lastTickAt
+            ? Math.max(0, Math.round((now.getTime() - new Date(prior.lastTickAt).getTime()) / 60_000))
+            : 0;
+        const prompt = [
+            `[Heartbeat check-in: ${profile.slug}]`,
+            '',
+            `You are ${profile.name}. ${profile.description}`,
+            '',
+            `## Routine check-in`,
+            `This is your scheduled heartbeat tick (${sinceLastMin}min since last).`,
+            `Something in your scope has changed since you last checked in.`,
+            '',
+            `### Signals`,
+            `- Pending delegated tasks: ${signals.pendingTasks ?? 0}`,
+            `- Latest goal update: ${signals.latestGoalUpdate || 'none'}`,
+            `- Latest cron run: ${signals.latestCronRunMs ? new Date(Number(signals.latestCronRunMs)).toISOString() : 'none'}`,
+            '',
+            `### Instructions`,
+            `1. Quickly scan TASKS.md, your goals, and recent cron output for anything that needs action right now.`,
+            `2. If there's a clear next action you can take in 1–2 turns, do it.`,
+            `3. If you're blocked, waiting on someone, or it's all-quiet, say so concisely.`,
+            `4. End your response with \`[NEXT_CHECK: Xm]\` to set when to check in next (5–720 min). Default 30m. Use shorter intervals during active work, longer during quiet hours.`,
+            `5. Keep your response under 3 sentences unless you actually took action.`,
+        ].join('\n');
+        const jobName = `heartbeat:${this.slug}`;
+        const result = await this.gateway.handleCronJob(jobName, prompt, 1, 5, undefined, undefined, 'standard', undefined, undefined, undefined, this.slug);
+        const parsed = AgentHeartbeatScheduler.parseLlmTickOutput(result);
+        return { nextCheckMinutes: parsed.nextCheckMinutes, summary: parsed.summary };
+    }
+    /** Parse `[NEXT_CHECK: Xm]` directive from the agent's output. Public for tests. */
+    static parseLlmTickOutput(output) {
+        const match = output.match(/\[NEXT_CHECK:\s*(\d+)\s*m?\]/i);
+        const nextCheckMinutes = match ? parseInt(match[1], 10) : undefined;
+        // Strip the directive from the summary so logs don't echo it back
+        const summary = output.replace(/\[NEXT_CHECK:[^\]]*\]/gi, '').trim();
+        return { nextCheckMinutes, summary };
+    }
+    /** Schedule the next check explicitly. Clamped to [MIN, MAX] minutes. */
+    setNextCheckIn(minutes, now = new Date()) {
+        const clamped = Math.max(MIN_INTERVAL_MIN, Math.min(MAX_INTERVAL_MIN, Math.floor(minutes)));
+        const prior = this.loadState();
+        const state = {
+            ...prior,
+            slug: this.slug,
+            nextCheckAt: new Date(now.getTime() + clamped * 60_000).toISOString(),
+        };
+        this.saveState(state);
+    }
+    getSlug() {
+        return this.slug;
+    }
+}
+//# sourceMappingURL=agent-heartbeat-scheduler.js.map

package/dist/gateway/heartbeat-scheduler.js

@@ -9,8 +9,8 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync,
 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 { HEARTBEAT_FILE, TASKS_FILE, INBOX_DIR, DAILY_NOTES_DIR, HEARTBEAT_INTERVAL_MINUTES, HEARTBEAT_ACTIVE_START, HEARTBEAT_ACTIVE_END, BASE_DIR, GOALS_DIR, AGENTS_DIR, HEARTBEAT_WORK_QUEUE_FILE, DISCORD_OWNER_ID, } from '../config.js';
+import { findGoalPath, listAllGoals } from '../tools/shared.js';
 import { gatherInsightSignals, buildInsightPrompt, parseInsightResponse, canSendInsight, recordInsightSent, recordInsightAcked, maybeIncreaseCooldown, } from '../agent/insight-engine.js';
 import { decideDailyPlanPriority, decideDiscoveredWorkItem, decideGoalAdvancement, decisionShouldCreateGoalTrigger, decisionShouldQueueHeartbeatWork, } from '../agent/proactive-engine.js';
 import { recentDecisions, recordDecision, recordDecisionOutcome, wasRecentlyDecided, } from '../agent/proactive-ledger.js';
@@ -444,6 +444,35 @@ export class HeartbeatScheduler {
                         continue;
                     if (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
                         continue;
+                    // If the goal belongs to a specialist agent, route to them via a
+                    // goal-trigger file instead of running the work as Clementine.
+                    // processGoalTriggers in cron-scheduler reads goal.owner and
+                    // dispatches with the right profile + Discord channel.
+                    const goalLookup = findGoalPath(priority.id);
+                    const ownerSlug = goalLookup && goalLookup.owner !== 'clementine' ? goalLookup.owner : null;
+                    if (ownerSlug) {
+                        const goalTriggerDir = path.join(BASE_DIR, 'cron', 'goal-triggers');
+                        mkdirSync(goalTriggerDir, { recursive: true });
+                        const trigger = {
+                            goalId: priority.id,
+                            focus: priority.action,
+                            maxTurns: 15,
+                            triggeredAt: new Date().toISOString(),
+                            source: 'daily-plan',
+                            decision,
+                        };
+                        const triggerPath = path.join(goalTriggerDir, `${decision.idempotencyKey}.trigger.json`);
+                        writeFileSync(triggerPath, JSON.stringify(trigger, null, 2));
+                        recordDecision(decision, {
+                            signalType: 'daily-plan-priority',
+                            description: priority.action,
+                            goalId: priority.id,
+                            owner: ownerSlug,
+                            metadata: { planDate: todayPlan.date, type: priority.type, routedTo: ownerSlug },
+                        });
+                        logger.info({ goalId: priority.id, owner: ownerSlug, action: priority.action }, 'Routed daily-plan goal to owning agent');
+                        continue;
+                    }
                     HeartbeatScheduler.enqueueWork({
                         description: priority.action,
                         prompt: `Goal progress: ${priority.action}\n\nThis is a high-priority item from today's daily plan (goal: ${priority.id}). ` +
@@ -1231,18 +1260,45 @@ export class HeartbeatScheduler {
                         // If move fails, skip — will retry next tick
                         continue;
                     }
+                    // Load active team so Clementine can delegate when an item belongs
+                    // to a specialist. Read agent.md frontmatter for slug/name/scope.
+                    const teamLines = [];
+                    try {
+                        if (existsSync(AGENTS_DIR)) {
+                            const agentDirs = readdirSync(AGENTS_DIR, { withFileTypes: true })
+                                .filter((d) => d.isDirectory() && !d.name.startsWith('_'))
+                                .map((d) => d.name);
+                            for (const slug of agentDirs) {
+                                const agentMd = path.join(AGENTS_DIR, slug, 'agent.md');
+                                if (!existsSync(agentMd))
+                                    continue;
+                                try {
+                                    const fm = matter(readFileSync(agentMd, 'utf-8')).data;
+                                    const desc = (fm.description ?? '').replace(/\s+/g, ' ').trim().slice(0, 160);
+                                    teamLines.push(`- \`${slug}\` (${fm.name ?? slug})${desc ? ` — ${desc}` : ''}`);
+                                }
+                                catch { /* skip malformed agent.md */ }
+                            }
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                    const teamBlock = teamLines.length > 0
+                        ? `## Your Team (delegate when work clearly belongs to one of them)\n${teamLines.join('\n')}\n\n`
+                        : '';
                     // Build a prompt for the agent to triage this inbox item
                     const prompt = `Triage this inbox item and take appropriate action.\n\n` +
                         `**Title:** ${title}\n` +
                         `**Content:**\n${content.slice(0, 2000)}\n\n` +
+                        teamBlock +
                         `## Instructions:\n` +
-                        `1. Determine the intent: Is this a task, a reference/note, a reminder, or something else?\n` +
+                        `1. Determine the intent: Is this a task, a reference/note, a reminder, project update, or work for a teammate?\n` +
                         `2. Take the appropriate action:\n` +
                         `   - **Task**: Use \`task_add\` to create a task with the right priority and due date.\n` +
                         `   - **Reference**: Use \`note_create\` or \`memory_write\` to file it in the vault.\n` +
                         `   - **Reminder**: Add to today's daily note with \`memory_write(action="append_daily")\`.\n` +
                         `   - **Project update**: Update the relevant project note.\n` +
-                        `3. Respond with a one-line summary of what you did.`;
+                        `   - **Delegate to a teammate**: If the item is clearly work for a specialist on your team, use \`team_message\` to hand it off with enough context for them to act. Don't try to do their job yourself.\n` +
+                        `3. Respond with a one-line summary of what you did (including who you delegated to, if anyone).`;
                     // Fire-and-forget — run as a lightweight cron job
                     this.gateway
                         .handleCronJob(`inbox:${title}`, prompt, 1, 5)

package/dist/index.js

@@ -453,28 +453,36 @@ function startTimerChecker(dispatcher, gateway) {
 // ── Log rotation ─────────────────────────────────────────────────────
 const LOG_MAX_BYTES = 2 * 1024 * 1024; // 2 MB
 const LOG_MAX_BACKUPS = 7;
+function rotateOne(logFile) {
+    if (!existsSync(logFile))
+        return;
+    const size = statSync(logFile).size;
+    if (size < LOG_MAX_BYTES)
+        return;
+    // Rotate: delete .log.7, shift .log.6→.log.7, ... .log→.log.1
+    const oldest = `${logFile}.${LOG_MAX_BACKUPS}`;
+    if (existsSync(oldest))
+        unlinkSync(oldest);
+    for (let i = LOG_MAX_BACKUPS - 1; i >= 1; i--) {
+        const src = `${logFile}.${i}`;
+        if (existsSync(src))
+            renameSync(src, `${logFile}.${i + 1}`);
+    }
+    renameSync(logFile, `${logFile}.1`);
+    writeFileSync(logFile, '');
+}
 function rotateLogIfNeeded() {
-    const logFile = path.join(config.BASE_DIR, 'logs', 'clementine.log');
-    try {
-        if (!existsSync(logFile))
-            return;
-        const size = statSync(logFile).size;
-        if (size < LOG_MAX_BYTES)
-            return;
-        // Rotate: delete .log.7, shift .log.6→.log.7, ... .log→.log.1
-        const oldest = `${logFile}.${LOG_MAX_BACKUPS}`;
-        if (existsSync(oldest))
-            unlinkSync(oldest);
-        for (let i = LOG_MAX_BACKUPS - 1; i >= 1; i--) {
-            const src = `${logFile}.${i}`;
-            if (existsSync(src))
-                renameSync(src, `${logFile}.${i + 1}`);
+    // cron.log is appended to by launchd-spawned `clementine cron run` invocations
+    // — each is a one-shot process that closes the FD after writing, so a
+    // rename-rotate at daemon startup is safe.
+    const logsDir = path.join(config.BASE_DIR, 'logs');
+    for (const name of ['clementine.log', 'cron.log']) {
+        try {
+            rotateOne(path.join(logsDir, name));
+        }
+        catch (err) {
+            logger.warn({ err, name }, 'Log rotation failed — continuing startup');
         }
-        renameSync(logFile, `${logFile}.1`);
-        writeFileSync(logFile, '');
-    }
-    catch (err) {
-        logger.warn({ err }, 'Log rotation failed — continuing startup');
     }
 }
 // ── Async main ───────────────────────────────────────────────────────
@@ -652,6 +660,11 @@ async function asyncMain() {
     const heartbeat = new HeartbeatScheduler(gateway, dispatcher);
     const cronScheduler = new CronScheduler(gateway, dispatcher);
     heartbeat.setCronScheduler(cronScheduler);
+    // Per-agent heartbeats (Ross / Sasha / Nora / future hires). Cheap-path
+    // observation on every tick; LLM tick fires on signal change with the
+    // agent's profile and routes output to their Discord channel.
+    const { AgentHeartbeatManager } = await import('./gateway/agent-heartbeat-manager.js');
+    const agentHeartbeats = new AgentHeartbeatManager(gateway.getAgentManager(), gateway);
     // ── Build channel tasks ──────────────────────────────────────────
     const channelTasks = [];
     const activeChannels = [];
@@ -748,6 +761,7 @@ async function asyncMain() {
     // Start heartbeat + cron + timers
     heartbeat.start();
     cronScheduler.start();
+    agentHeartbeats.start();
     const timerInterval = startTimerChecker(dispatcher, gateway);
     // Start brain ingest scheduler (polls registered REST sources on their cron)
     try {
@@ -938,6 +952,7 @@ async function asyncMain() {
     // Now safe to tear down remaining infrastructure
     heartbeat.stop();
     cronScheduler.stop();
+    agentHeartbeats.stop();
     // ── Self-restart (enhanced with health check + rollback) ────────
     if (restartRequested) {
         // Clear our PID file BEFORE spawning the child, so ensureSingleton()

package/dist/tools/session-tools.js

@@ -141,6 +141,11 @@ export function registerSessionTools(server) {
         const topItems = items.slice(0, maxItems);
         if (topItems.length === 0)
             return textResult('No work items discovered. All goals on track, no failures, inbox clear.');
+        // Decisions here are advisory — the agent surveys, then chooses whether
+        // to act. We deliberately do NOT recordDecision: the autonomous paths
+        // (processInbox, daily-plan loop, goal advancement) record their own
+        // decisions when they actually act, so the ledger reflects committed
+        // decisions and proactive_stats stays signal-rich.
         const lines = topItems.map((i) => {
             const decision = decideDiscoveredWorkItem(i);
             const label = ACTION_LABEL[decision.action];

package/dist/types.d.ts

@@ -221,6 +221,19 @@ export interface HeartbeatWorkItem {
     error?: string;
     agentSlug?: string;
 }
+/**
+ * State for one specialist agent's heartbeat scheduler. Persisted at
+ * ~/.clementine/heartbeat/agents/<slug>/state.json. Manager reads
+ * `nextCheckAt` to decide whether the agent is due for a tick.
+ */
+export interface AgentHeartbeatState {
+    slug: string;
+    lastTickAt: string;
+    nextCheckAt: string;
+    silentTickCount: number;
+    fingerprint: string;
+    lastSignalSummary?: string;
+}
 export interface CronJobDefinition {
     name: string;
     schedule: string;

package/package.json

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