clementine-agent 1.0.76 → 1.0.78

package/dist/gateway/heartbeat-scheduler.js

@@ -9,11 +9,14 @@ 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';
 import { CronRunLog, logToDailyNote, todayISO } from './cron-scheduler.js';
 const logger = pino({ name: 'clementine.heartbeat' });
+const PROACTIVE_DECISION_DEDUPE_MS = 24 * 60 * 60 * 1000;
 // ── HeartbeatScheduler ────────────────────────────────────────────────
 export class HeartbeatScheduler {
     stateFile;
@@ -307,6 +310,14 @@ export class HeartbeatScheduler {
         // ── Active hours check ────────────────────────────────────────────
         // Check active hours
         if (hour < HEARTBEAT_ACTIVE_START || hour >= HEARTBEAT_ACTIVE_END) {
+            // Critical proactive alerts are allowed outside active hours; normal
+            // heartbeat narration still stays quiet.
+            try {
+                await this.runInsightCheck();
+            }
+            catch (err) {
+                logger.debug({ err }, 'Outside-hours insight check failed (non-fatal)');
+            }
             logger.debug(`Heartbeat skipped: outside active hours (${hour}:00)`);
             return;
         }
@@ -319,26 +330,61 @@ export class HeartbeatScheduler {
                 logger.info('First active-hours tick — generating daily plan');
                 const plan = await dailyPlanner.plan();
                 if (plan.priorities.length > 0) {
-                    const highUrgency = plan.priorities.filter(p => p.urgency >= 4);
-                    if (highUrgency.length > 0) {
-                        const goalTriggerDir = path.join(BASE_DIR, 'cron', 'goal-triggers');
-                        mkdirSync(goalTriggerDir, { recursive: true });
-                        for (const item of highUrgency) {
-                            if (item.type === 'goal') {
-                                const triggerPath = path.join(goalTriggerDir, `${item.id}.trigger.json`);
-                                if (!existsSync(triggerPath)) {
-                                    writeFileSync(triggerPath, JSON.stringify({
-                                        goalId: item.id,
-                                        focus: item.action,
-                                        maxTurns: 30,
-                                        triggeredAt: new Date().toISOString(),
-                                        source: 'daily-plan',
-                                    }, null, 2));
-                                }
+                    const goalTriggerDir = path.join(BASE_DIR, 'cron', 'goal-triggers');
+                    mkdirSync(goalTriggerDir, { recursive: true });
+                    let acted = 0;
+                    let queued = 0;
+                    let askUser = 0;
+                    for (const item of plan.priorities) {
+                        const decision = decideDailyPlanPriority({ priority: item, date: plan.date });
+                        if (decision.action === 'ask_user')
+                            askUser++;
+                        if (item.type === 'goal' && decisionShouldCreateGoalTrigger(decision)) {
+                            if (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
+                                continue;
+                            const triggerPath = path.join(goalTriggerDir, `${decision.idempotencyKey}.trigger.json`);
+                            if (!existsSync(triggerPath)) {
+                                writeFileSync(triggerPath, JSON.stringify({
+                                    goalId: item.id,
+                                    focus: item.action,
+                                    maxTurns: 30,
+                                    triggeredAt: new Date().toISOString(),
+                                    source: 'daily-plan',
+                                    decision,
+                                }, null, 2));
+                                recordDecision(decision, {
+                                    signalType: 'daily-plan-priority',
+                                    description: item.action,
+                                    goalId: item.id,
+                                    metadata: { planDate: plan.date, type: item.type },
+                                });
+                                acted++;
                             }
                         }
+                        else if (item.type === 'goal' && decisionShouldQueueHeartbeatWork(decision)) {
+                            if (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
+                                continue;
+                            HeartbeatScheduler.enqueueWork({
+                                description: item.action,
+                                prompt: `Goal progress: ${item.action}\n\nThis is a medium-priority item from today's daily plan (goal: ${item.id}). ` +
+                                    `Use goal_work to make progress. If you need information from the owner to proceed, ` +
+                                    `note the blocker and move on.`,
+                                source: `daily-plan:${item.id}`,
+                                idempotencyKey: decision.idempotencyKey,
+                                priority: 'normal',
+                                maxTurns: 10,
+                                tier: 1,
+                            });
+                            recordDecision(decision, {
+                                signalType: 'daily-plan-priority',
+                                description: item.action,
+                                goalId: item.id,
+                                metadata: { planDate: plan.date, type: item.type },
+                            });
+                            queued++;
+                        }
                     }
-                    logger.info({ priorities: plan.priorities.length, urgent: plan.priorities.filter(p => p.urgency >= 4).length }, 'Daily plan generated');
+                    logger.info({ priorities: plan.priorities.length, acted, queued, askUser }, 'Daily plan generated and evaluated');
                 }
                 // Apply non-destructive cron changes suggested by the daily planner
                 if (plan.suggestedCronChanges?.length > 0 && this.cronScheduler) {
@@ -390,29 +436,60 @@ export class HeartbeatScheduler {
                 changesSummary += `\n\n## Today's Plan\n${todayPlan.summary}\nTop priorities: ${todayPlan.priorities.slice(0, 3).map(p => p.action).join('; ')}`;
                 // ── Goal-driven work auto-queuing ─────────────────────────
                 // Close the loop: daily planner priorities → work queue items
-                // Only queue high-urgency goal items that are autonomously actionable
-                const currentQueue = HeartbeatScheduler.loadWorkQueue();
-                const pendingDescriptions = new Set(currentQueue.filter(i => i.status === 'pending' || i.status === 'running').map(i => i.description));
+                // The proactive ledger (wasRecentlyDecided) plus enqueueWork's
+                // in-flight dedup cover what the old description-based set was for.
                 for (const priority of todayPlan.priorities) {
-                    // Only auto-queue high-urgency goal items (urgency >= 7)
-                    if (priority.type !== 'goal' || priority.urgency < 7)
+                    const decision = decideDailyPlanPriority({ priority, date: todayPlan.date });
+                    if (priority.type !== 'goal' || !decisionShouldQueueHeartbeatWork(decision))
                         continue;
-                    // Skip if already queued
-                    if (pendingDescriptions.has(priority.action))
+                    if (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
                         continue;
-                    // Skip if the action requires human input (heuristic: contains question marks or decision words)
-                    if (/\?|decide|choose|approve|confirm|review with|ask\s/i.test(priority.action))
+                    // 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}). ` +
                             `Use goal_work to make progress. If you need information from the owner to proceed, ` +
                             `note the blocker and move on.`,
                         source: `daily-plan:${priority.id}`,
+                        idempotencyKey: decision.idempotencyKey,
                         priority: 'high',
                         maxTurns: 10,
                         tier: 1,
                     });
+                    recordDecision(decision, {
+                        signalType: 'daily-plan-priority',
+                        description: priority.action,
+                        goalId: priority.id,
+                        metadata: { planDate: todayPlan.date, type: priority.type },
+                    });
                     logger.info({ goalId: priority.id, action: priority.action }, 'Auto-queued goal work from daily plan');
                 }
             }
@@ -432,10 +509,12 @@ export class HeartbeatScheduler {
                 this.completeItem(item.id, result || 'completed');
                 completedWork.push({ description: item.description, result: result || 'completed' });
                 logToDailyNote(`**Heartbeat work: ${item.description}** — ${(result || 'completed').slice(0, 100).replace(/\n/g, ' ')}`);
+                this.recordWorkItemOutcome(item, 'advanced', result || 'completed');
             }
             catch (err) {
                 this.failItem(item.id, String(err));
                 logger.warn({ err, id: item.id }, 'Heartbeat work item failed');
+                this.recordWorkItemOutcome(item, 'failed', String(err));
             }
         }
         // ── Decide whether to invoke the LLM ──
@@ -907,7 +986,8 @@ export class HeartbeatScheduler {
             const activeGoals = allGoals.filter((g) => g && g.status === 'active');
             if (activeGoals.length === 0)
                 return null;
-            const now = Date.now();
+            const nowDate = new Date();
+            const now = nowDate.getTime();
             const DAY_MS = 86_400_000;
             const lines = activeGoals.map((g) => {
                 const nextAct = g.nextActions?.length > 0 ? ` | Next: ${g.nextActions[0]}` : '';
@@ -998,8 +1078,8 @@ export class HeartbeatScheduler {
             const allGoals = preloadedGoals ?? HeartbeatScheduler.loadAllGoals();
             if (allGoals.length === 0)
                 return;
-            const now = Date.now();
-            const DAY_MS = 86_400_000;
+            const nowDate = new Date();
+            const now = nowDate.getTime();
             // Load recent goal outcomes for disposition-based throttling.
             // The agent classifies each outcome (ADVANCED, BLOCKED_ON_USER, etc.)
             // and we use that to decide when/whether to retry.
@@ -1059,47 +1139,20 @@ export class HeartbeatScheduler {
                 }
             }
             catch { /* non-fatal */ }
-            // Score ALL active goals — stale goals get urgency bonus, but
-            // non-stale high-priority goals with pending work also qualify.
+            // Score ALL active goals through the proactive decision engine. Stale
+            // goals get urgency, but current high-priority goals with pending work
+            // also qualify.
             const scoredGoals = [];
             for (const goal of allGoals) {
                 try {
-                    if (goal.status !== 'active')
-                        continue;
-                    // Skip goals in cooldown (failed recently or producing stale output)
-                    if (goalCooldowns.has(goal.id))
-                        continue;
-                    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;
-                    const isStale = daysSinceUpdate > staleThreshold;
-                    const hasWork = (goal.nextActions?.length ?? 0) > 0;
-                    // Skip non-stale goals that have no pending work
-                    if (!isStale && !hasWork)
-                        continue;
-                    // Scoring: priority (high=15, medium=8, low=2) + staleness bonus + work availability
-                    const priorityScore = goal.priority === 'high' ? 15 : goal.priority === 'medium' ? 8 : 2;
-                    const stalenessScore = isStale ? Math.min(daysSinceUpdate - staleThreshold, 20) : 0;
-                    const workScore = hasWork ? 5 : 0;
-                    // Goals approaching target date get a deadline urgency boost
-                    let deadlineScore = 0;
-                    if (goal.targetDate) {
-                        const daysUntilTarget = Math.floor((new Date(goal.targetDate).getTime() - now) / DAY_MS);
-                        if (daysUntilTarget <= 0)
-                            deadlineScore = 20; // overdue
-                        else if (daysUntilTarget <= 3)
-                            deadlineScore = 10; // imminent
-                        else if (daysUntilTarget <= 7)
-                            deadlineScore = 5; // approaching
+                    const advancement = decideGoalAdvancement({
+                        goal,
+                        now: nowDate,
+                        inCooldown: goalCooldowns.has(goal.id),
+                    });
+                    if (advancement && decisionShouldCreateGoalTrigger(advancement.decision)) {
+                        scoredGoals.push(advancement);
                     }
-                    const totalScore = priorityScore + stalenessScore + workScore + deadlineScore;
-                    const reason = [
-                        isStale ? `stale(${daysSinceUpdate}d)` : 'current',
-                        `pri=${goal.priority}`,
-                        hasWork ? 'has-work' : 'no-work',
-                        deadlineScore > 0 ? `deadline-boost(${deadlineScore})` : '',
-                    ].filter(Boolean).join(', ');
-                    scoredGoals.push({ goal, score: totalScore, reason });
                 }
                 catch {
                     continue;
@@ -1110,10 +1163,9 @@ export class HeartbeatScheduler {
             // Sort by score descending, take top 2
             scoredGoals.sort((a, b) => b.score - a.score);
             const toAdvance = scoredGoals.slice(0, 2);
-            for (const { goal, reason } of toAdvance) {
-                const focus = goal.nextActions?.length > 0
-                    ? goal.nextActions[0]
-                    : `Review and update progress on "${goal.title}"`;
+            for (const { goal, reason, focus, decision, score } of toAdvance) {
+                if (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
+                    continue;
                 const trigger = {
                     goalId: goal.id,
                     focus,
@@ -1121,10 +1173,18 @@ export class HeartbeatScheduler {
                     triggeredAt: new Date().toISOString(),
                     source: 'heartbeat-advance',
                     reason,
+                    decision,
                 };
-                const triggerPath = path.join(goalTriggerDir, `${goal.id}.trigger.json`);
+                const triggerPath = path.join(goalTriggerDir, `${decision.idempotencyKey}.trigger.json`);
                 writeFileSync(triggerPath, JSON.stringify(trigger, null, 2));
-                logger.info({ goalId: goal.id, title: goal.title, score: toAdvance[0].score, reason, focus }, 'Advancing goal via trigger');
+                recordDecision(decision, {
+                    signalType: 'goal-advancement',
+                    description: focus,
+                    goalId: goal.id,
+                    owner: goal.owner,
+                    metadata: { score, reason, title: goal.title },
+                });
+                logger.info({ goalId: goal.id, title: goal.title, score, reason, focus, decision: decision.action }, 'Advancing goal via trigger');
             }
             // Note: task generation removed — the main goal trigger already includes
             // nextActions[0] as focus, so a separate task-gen trigger was redundant
@@ -1158,6 +1218,38 @@ export class HeartbeatScheduler {
                 try {
                     const content = readFileSync(filePath, 'utf-8');
                     const title = file.replace(/\.md$/, '');
+                    const decision = decideDiscoveredWorkItem({
+                        type: 'inbox',
+                        id: title,
+                        description: `Triage inbox item: ${title}`,
+                        urgency: 2,
+                        source: 'inbox',
+                    });
+                    if (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
+                        continue;
+                    if (decision.action !== 'act_now') {
+                        HeartbeatScheduler.enqueueWork({
+                            description: `Triage inbox item: ${title}`,
+                            prompt: `Triage this inbox item later: ${title}`,
+                            source: `inbox:${title}`,
+                            idempotencyKey: decision.idempotencyKey,
+                            priority: 'normal',
+                            maxTurns: 5,
+                            tier: 1,
+                        });
+                        recordDecision(decision, {
+                            signalType: 'inbox-triage',
+                            description: `Triage inbox item: ${title}`,
+                            metadata: { file },
+                        });
+                        continue;
+                    }
+                    const decisionContext = {
+                        signalType: 'inbox-triage',
+                        description: `Triage inbox item: ${title}`,
+                        metadata: { file },
+                    };
+                    const decisionRecord = recordDecision(decision, decisionContext);
                     // Move file before processing to prevent duplicate triage on next tick
                     const destPath = path.join(processedDir, file);
                     try {
@@ -1168,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)
@@ -1188,6 +1307,15 @@ export class HeartbeatScheduler {
                             logToDailyNote(`**Inbox processed: ${title}** — ${result.slice(0, 100).replace(/\n/g, ' ')}`);
                         }
                         logger.info({ file: title }, 'Inbox item processed');
+                        try {
+                            recordDecisionOutcome(decisionRecord.id, decision, decisionContext, {
+                                status: 'advanced',
+                                summary: (result ?? 'processed').slice(0, 200),
+                            });
+                        }
+                        catch (err) {
+                            logger.debug({ err, file: title }, 'Failed to record inbox outcome (non-fatal)');
+                        }
                     })
                         .catch((err) => {
                         // Restore file to inbox on failure so it retries
@@ -1197,6 +1325,15 @@ export class HeartbeatScheduler {
                         }
                         catch { /* best-effort restore */ }
                         logger.warn({ err, file: title }, 'Failed to process inbox item');
+                        try {
+                            recordDecisionOutcome(decisionRecord.id, decision, decisionContext, {
+                                status: 'failed',
+                                summary: String(err).slice(0, 200),
+                            });
+                        }
+                        catch (recordErr) {
+                            logger.debug({ err: recordErr, file: title }, 'Failed to record inbox outcome (non-fatal)');
+                        }
                     });
                 }
                 catch (err) {
@@ -1349,14 +1486,40 @@ export class HeartbeatScheduler {
             HeartbeatScheduler.saveWorkQueue(queue);
         }
     }
+    recordWorkItemOutcome(item, status, summary) {
+        const key = item.idempotencyKey;
+        if (!key)
+            return;
+        try {
+            const original = recentDecisions({ idempotencyKey: key }, undefined)[0];
+            if (!original)
+                return;
+            recordDecisionOutcome(original.id, original.decision, original.context, {
+                status,
+                summary: summary.slice(0, 200),
+            });
+        }
+        catch (err) {
+            logger.debug({ err, id: item.id }, 'Failed to record work-item outcome (non-fatal)');
+        }
+    }
     static enqueueWork(opts) {
         const queue = HeartbeatScheduler.loadWorkQueue();
+        // Only dedup against in-flight items here. Cross-tick "we already acted on this
+        // signal" lives in the proactive ledger (wasRecentlyDecided); blocking on
+        // 'completed' here would prevent legitimate re-runs of multi-session work.
+        const dedupKey = opts.idempotencyKey ?? opts.source;
+        const existing = queue.find((item) => (item.idempotencyKey ?? item.source) === dedupKey &&
+            (item.status === 'pending' || item.status === 'running'));
+        if (existing)
+            return existing.id;
         const id = randomBytes(4).toString('hex');
         const item = {
             id,
             description: opts.description,
             prompt: opts.prompt,
             source: opts.source,
+            ...(opts.idempotencyKey ? { idempotencyKey: opts.idempotencyKey } : {}),
             priority: opts.priority ?? 'normal',
             queuedAt: new Date().toISOString(),
             maxTurns: opts.maxTurns ?? 3,

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,10 @@ 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 only in P2 — LLM ticks land in P3.
+    const { AgentHeartbeatManager } = await import('./gateway/agent-heartbeat-manager.js');
+    const agentHeartbeats = new AgentHeartbeatManager(gateway.getAgentManager());
     // ── Build channel tasks ──────────────────────────────────────────
     const channelTasks = [];
     const activeChannels = [];
@@ -748,6 +760,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 +951,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()