clementine-agent 1.0.76 → 1.0.78

package/dist/agent/insight-engine.js

@@ -108,7 +108,7 @@ export function gatherInsightSignals(gateway) {
     catch { /* non-fatal */ }
     // 2. Check for cron job failures
     try {
-        const runLogDir = path.join(BASE_DIR, 'cron', 'run-log');
+        const runLogDir = path.join(BASE_DIR, 'cron', 'runs');
         if (existsSync(runLogDir)) {
             const logFiles = readdirSync(runLogDir).filter(f => f.endsWith('.jsonl')).slice(0, 10);
             for (const file of logFiles) {
@@ -118,7 +118,8 @@ export function gatherInsightSignals(gateway) {
                     continue;
                 try {
                     const entry = JSON.parse(lastLine);
-                    if (new Date(entry.timestamp) > new Date(twoHoursAgo) && entry.status === 'error') {
+                    const finishedAt = entry.finishedAt ?? entry.timestamp;
+                    if (finishedAt && new Date(finishedAt) > new Date(twoHoursAgo) && entry.status === 'error') {
                         signals.push(`Cron job "${entry.jobName || file.replace('.jsonl', '')}" failed: ${(entry.error || '').slice(0, 100)}`);
                     }
                 }

package/dist/agent/proactive-engine.d.ts

@@ -0,0 +1,50 @@
+import type { DailyPlanPriority, PersistentGoal } from '../types.js';
+export type ProactiveAction = 'act_now' | 'queue' | 'ask_user' | 'snooze' | 'ignore';
+export type ProactiveSource = 'daily-plan' | 'goal' | 'cron' | 'inbox' | 'insight' | 'manual';
+export interface ProactiveDecision {
+    action: ProactiveAction;
+    source: ProactiveSource;
+    reason: string;
+    urgency: number;
+    confidence: number;
+    authorityTier: 1 | 2 | 3;
+    idempotencyKey: string;
+    nextCheckAt?: string;
+}
+export interface DailyPlanDecisionInput {
+    priority: DailyPlanPriority;
+    date: string;
+    goalAutoSchedule?: boolean;
+    now?: Date;
+}
+export type ProactiveWorkType = 'stale-goal' | 'cron-failure' | 'overdue-tasks' | 'inbox' | `plan-${DailyPlanPriority['type']}` | 'unknown';
+export interface ProactiveWorkItem {
+    type: ProactiveWorkType;
+    id?: string;
+    description: string;
+    urgency: number;
+    source?: ProactiveSource;
+}
+export interface GoalAdvancementDecision {
+    goal: PersistentGoal;
+    decision: ProactiveDecision;
+    score: number;
+    focus: string;
+    reason: string;
+}
+export interface GoalAdvancementInput {
+    goal: PersistentGoal;
+    now?: Date;
+    inCooldown?: boolean;
+}
+export declare function requiresHumanInput(text: string): boolean;
+/**
+ * Deterministic first-pass decision for daily-plan priorities.
+ * The LLM decides what matters; this layer decides what the daemon may do.
+ */
+export declare function decideDailyPlanPriority(input: DailyPlanDecisionInput): ProactiveDecision;
+export declare function decisionShouldCreateGoalTrigger(decision: ProactiveDecision): boolean;
+export declare function decisionShouldQueueHeartbeatWork(decision: ProactiveDecision): boolean;
+export declare function decideDiscoveredWorkItem(item: ProactiveWorkItem, now?: Date): ProactiveDecision;
+export declare function decideGoalAdvancement(input: GoalAdvancementInput): GoalAdvancementDecision | null;
+//# sourceMappingURL=proactive-engine.d.ts.map

package/dist/agent/proactive-engine.js

@@ -0,0 +1,256 @@
+import { createHash } from 'node:crypto';
+const HUMAN_INPUT_PATTERN = /\?|decide|choose|approve|confirm|review with|ask\s/i;
+function shortHash(value) {
+    return createHash('sha1').update(value).digest('hex').slice(0, 10);
+}
+export function requiresHumanInput(text) {
+    return HUMAN_INPUT_PATTERN.test(text);
+}
+function clampUrgency(value) {
+    if (!Number.isFinite(value))
+        return 1;
+    return Math.max(1, Math.min(5, Math.round(value)));
+}
+function snoozeUntil(now, hours) {
+    return new Date(now.getTime() + hours * 60 * 60 * 1000).toISOString();
+}
+/**
+ * Deterministic first-pass decision for daily-plan priorities.
+ * The LLM decides what matters; this layer decides what the daemon may do.
+ */
+export function decideDailyPlanPriority(input) {
+    const { priority, date, goalAutoSchedule = false, now = new Date() } = input;
+    const urgency = clampUrgency(priority.urgency);
+    const keyBase = `${date}:${priority.type}:${priority.id}:${priority.action}`;
+    const idempotencyKey = `daily-plan:${shortHash(keyBase)}`;
+    if (!priority.action.trim()) {
+        return {
+            action: 'ignore',
+            source: 'daily-plan',
+            reason: 'Daily plan priority had no actionable description.',
+            urgency,
+            confidence: 0.2,
+            authorityTier: 1,
+            idempotencyKey,
+        };
+    }
+    if (requiresHumanInput(priority.action)) {
+        return {
+            action: urgency >= 4 ? 'ask_user' : 'snooze',
+            source: 'daily-plan',
+            reason: 'Priority appears to require owner input before action.',
+            urgency,
+            confidence: 0.75,
+            authorityTier: 1,
+            idempotencyKey,
+            nextCheckAt: snoozeUntil(now, urgency >= 4 ? 4 : 24),
+        };
+    }
+    if (priority.type === 'goal') {
+        if (urgency >= 4) {
+            return {
+                action: 'act_now',
+                source: 'daily-plan',
+                reason: 'High-urgency goal priority is autonomously actionable.',
+                urgency,
+                confidence: goalAutoSchedule ? 0.9 : 0.8,
+                authorityTier: 2,
+                idempotencyKey,
+            };
+        }
+        if (urgency >= 3) {
+            return {
+                action: 'queue',
+                source: 'daily-plan',
+                reason: 'Medium-urgency goal priority should be queued for heartbeat work.',
+                urgency,
+                confidence: 0.7,
+                authorityTier: 1,
+                idempotencyKey,
+                nextCheckAt: snoozeUntil(now, 2),
+            };
+        }
+    }
+    if (priority.type === 'cron-fix' && urgency >= 4) {
+        return {
+            action: 'ask_user',
+            source: 'daily-plan',
+            reason: 'Cron fixes can change autonomous behavior and should be confirmed.',
+            urgency,
+            confidence: 0.75,
+            authorityTier: 2,
+            idempotencyKey,
+        };
+    }
+    return {
+        action: urgency >= 3 ? 'snooze' : 'ignore',
+        source: 'daily-plan',
+        reason: 'Priority is not urgent enough for autonomous action.',
+        urgency,
+        confidence: 0.65,
+        authorityTier: 1,
+        idempotencyKey,
+        nextCheckAt: snoozeUntil(now, 24),
+    };
+}
+export function decisionShouldCreateGoalTrigger(decision) {
+    return decision.action === 'act_now' && decision.authorityTier <= 2 && decision.confidence >= 0.7;
+}
+export function decisionShouldQueueHeartbeatWork(decision) {
+    return decision.action === 'queue' && decision.authorityTier === 1 && decision.confidence >= 0.65;
+}
+export function decideDiscoveredWorkItem(item, now = new Date()) {
+    const urgency = clampUrgency(item.urgency);
+    const source = item.source ?? (item.type === 'cron-failure' ? 'cron'
+        : item.type === 'inbox' ? 'inbox'
+            : item.type === 'stale-goal' ? 'goal'
+                : item.type.startsWith('plan-') ? 'daily-plan'
+                    : 'manual');
+    const idempotencyKey = `${source}:${shortHash(`${item.type}:${item.id ?? ''}:${item.description}`)}`;
+    if (!item.description.trim()) {
+        return {
+            action: 'ignore',
+            source,
+            reason: 'Work item had no actionable description.',
+            urgency,
+            confidence: 0.2,
+            authorityTier: 1,
+            idempotencyKey,
+        };
+    }
+    if (requiresHumanInput(item.description)) {
+        return {
+            action: urgency >= 4 ? 'ask_user' : 'snooze',
+            source,
+            reason: 'Work item appears to require owner input.',
+            urgency,
+            confidence: 0.7,
+            authorityTier: 1,
+            idempotencyKey,
+            nextCheckAt: snoozeUntil(now, urgency >= 4 ? 4 : 24),
+        };
+    }
+    switch (item.type) {
+        case 'cron-failure':
+            return {
+                action: urgency >= 4 ? 'ask_user' : 'queue',
+                source,
+                reason: urgency >= 4
+                    ? 'Repeated cron failure may require owner approval before changing automation.'
+                    : 'Cron failure should be queued for diagnosis.',
+                urgency,
+                confidence: 0.75,
+                authorityTier: 2,
+                idempotencyKey,
+            };
+        case 'overdue-tasks':
+            return {
+                action: urgency >= 4 ? 'ask_user' : 'snooze',
+                source,
+                reason: 'Overdue tasks need owner attention unless a concrete next action is known.',
+                urgency,
+                confidence: 0.7,
+                authorityTier: 1,
+                idempotencyKey,
+                nextCheckAt: snoozeUntil(now, urgency >= 4 ? 4 : 24),
+            };
+        case 'inbox':
+            return {
+                action: urgency >= 2 ? 'act_now' : 'queue',
+                source,
+                reason: 'Inbox triage is a reversible tier-1 organization task.',
+                urgency,
+                confidence: 0.8,
+                authorityTier: 1,
+                idempotencyKey,
+            };
+        case 'stale-goal':
+        case 'plan-goal':
+            return {
+                action: urgency >= 4 ? 'act_now' : urgency >= 3 ? 'queue' : 'snooze',
+                source,
+                reason: 'Goal-related work can move autonomously when it has a concrete action.',
+                urgency,
+                confidence: 0.75,
+                authorityTier: urgency >= 4 ? 2 : 1,
+                idempotencyKey,
+                nextCheckAt: urgency < 4 ? snoozeUntil(now, 2) : undefined,
+            };
+        default:
+            return {
+                action: urgency >= 4 ? 'ask_user' : urgency >= 3 ? 'queue' : 'ignore',
+                source,
+                reason: 'Generic work item evaluated conservatively.',
+                urgency,
+                confidence: 0.6,
+                authorityTier: 1,
+                idempotencyKey,
+                nextCheckAt: urgency >= 3 && urgency < 4 ? snoozeUntil(now, 24) : undefined,
+            };
+    }
+}
+export function decideGoalAdvancement(input) {
+    const { goal, now = new Date(), inCooldown = false } = input;
+    if (goal.status !== 'active')
+        return null;
+    // Cooldown is a hard skip — the caller already decided we shouldn't act on
+    // this goal. Returning a snooze record here just got discarded downstream.
+    if (inCooldown)
+        return null;
+    const nowMs = now.getTime();
+    const dayMs = 86_400_000;
+    const lastUpdate = goal.updatedAt ? new Date(goal.updatedAt).getTime() : 0;
+    const daysSinceUpdate = Math.floor((nowMs - lastUpdate) / dayMs);
+    const staleThreshold = goal.reviewFrequency === 'daily' ? 1 : goal.reviewFrequency === 'weekly' ? 7 : 30;
+    const isStale = daysSinceUpdate > staleThreshold;
+    const hasWork = (goal.nextActions?.length ?? 0) > 0;
+    if (!isStale && !hasWork)
+        return null;
+    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;
+    let deadlineScore = 0;
+    if (goal.targetDate) {
+        const daysUntilTarget = Math.floor((new Date(goal.targetDate).getTime() - nowMs) / dayMs);
+        if (daysUntilTarget <= 0)
+            deadlineScore = 20;
+        else if (daysUntilTarget <= 3)
+            deadlineScore = 10;
+        else if (daysUntilTarget <= 7)
+            deadlineScore = 5;
+    }
+    const score = 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(', ');
+    const focus = goal.nextActions?.length > 0
+        ? goal.nextActions[0]
+        : `Review and update progress on "${goal.title}"`;
+    const idempotencyKey = `goal:${shortHash(`${goal.id}:${focus}`)}`;
+    const urgency = Math.min(5, Math.max(1, Math.ceil(score / 8)));
+    const action = score >= 13 ? 'act_now' : score >= 8 ? 'queue' : 'snooze';
+    return {
+        goal,
+        score,
+        focus,
+        reason,
+        decision: {
+            action,
+            source: 'goal',
+            reason: action === 'act_now'
+                ? 'Goal score is high enough for autonomous advancement.'
+                : action === 'queue'
+                    ? 'Goal should be queued, but not executed immediately.'
+                    : 'Goal is low urgency; check later.',
+            urgency,
+            confidence: action === 'act_now' ? 0.8 : 0.7,
+            authorityTier: action === 'act_now' ? 2 : 1,
+            idempotencyKey,
+            nextCheckAt: action === 'act_now' ? undefined : snoozeUntil(now, 2),
+        },
+    };
+}
+//# sourceMappingURL=proactive-engine.js.map

package/dist/agent/proactive-ledger.d.ts

@@ -0,0 +1,44 @@
+import type { ProactiveDecision } from './proactive-engine.js';
+export interface ProactiveDecisionContext {
+    signalType: string;
+    description: string;
+    goalId?: string;
+    owner?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface ProactiveDecisionOutcome {
+    status: 'advanced' | 'queued' | 'asked-user' | 'snoozed' | 'ignored' | 'blocked-on-user' | 'blocked-on-external' | 'needs-different-approach' | 'monitoring' | 'no-change' | 'failed';
+    summary: string;
+    recordedAt: string;
+}
+export interface ProactiveDecisionRecord {
+    id: string;
+    timestamp: string;
+    decision: ProactiveDecision;
+    context: ProactiveDecisionContext;
+    outcome?: ProactiveDecisionOutcome;
+}
+export interface ProactiveLedgerOptions {
+    filePath?: string;
+    now?: Date;
+}
+export declare function recordDecision(decision: ProactiveDecision, context: ProactiveDecisionContext, opts?: ProactiveLedgerOptions): ProactiveDecisionRecord;
+/**
+ * Append an outcome record. Event-sourced: outcomes are written as a NEW
+ * record sharing the original decision's `id`, not as in-place updates.
+ *
+ * `wasRecentlyDecided` therefore counts outcome records as "decided" — that
+ * is intentional. We don't want to re-act on a signal we've already handled,
+ * regardless of whether the latest entry is the original decision or its
+ * follow-up outcome.
+ */
+export declare function recordDecisionOutcome(decisionId: string, decision: ProactiveDecision, context: ProactiveDecisionContext, outcome: Omit<ProactiveDecisionOutcome, 'recordedAt'>, opts?: ProactiveLedgerOptions): ProactiveDecisionRecord;
+export declare function recentDecisions(filter?: Partial<{
+    idempotencyKey: string;
+    action: ProactiveDecision['action'];
+    source: ProactiveDecision['source'];
+    sinceMs: number;
+}>, opts?: ProactiveLedgerOptions): ProactiveDecisionRecord[];
+export declare function wasRecentlyDecided(idempotencyKey: string, windowMs: number, opts?: ProactiveLedgerOptions): boolean;
+export declare function outcomeStatusFromGoalDisposition(disposition: string): ProactiveDecisionOutcome['status'];
+//# sourceMappingURL=proactive-ledger.d.ts.map

package/dist/agent/proactive-ledger.js

@@ -0,0 +1,176 @@
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { BASE_DIR } from '../config.js';
+// Mirrors CronRunLog (cron-scheduler.ts) — keep the file bounded so reads
+// don't grow linearly forever.
+const MAX_BYTES = 2_000_000;
+const MAX_LINES = 2000;
+const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+// Per-file dedup cache: idempotencyKey → latest timestamp ms. Built lazily
+// on first lookup, kept in sync on every append.
+const dedupCache = new Map();
+const DEFAULT_LEDGER_FILE = path.join(BASE_DIR, 'proactive', 'decisions.jsonl');
+function ledgerPath(opts) {
+    return opts?.filePath ?? DEFAULT_LEDGER_FILE;
+}
+function hash(value) {
+    return createHash('sha1').update(value).digest('hex').slice(0, 12);
+}
+function readRecords(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    try {
+        return readFileSync(filePath, 'utf-8')
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+function getDedupCache(filePath) {
+    let cache = dedupCache.get(filePath);
+    if (cache)
+        return cache;
+    cache = new Map();
+    for (const record of readRecords(filePath)) {
+        const ts = new Date(record.timestamp).getTime();
+        if (!Number.isFinite(ts))
+            continue;
+        const prev = cache.get(record.decision.idempotencyKey) ?? 0;
+        if (ts > prev)
+            cache.set(record.decision.idempotencyKey, ts);
+    }
+    dedupCache.set(filePath, cache);
+    return cache;
+}
+function touchDedupCache(filePath, idempotencyKey, timestampMs) {
+    const cache = dedupCache.get(filePath);
+    if (!cache)
+        return; // not yet initialized — will be built fresh on next read
+    const prev = cache.get(idempotencyKey) ?? 0;
+    if (timestampMs > prev)
+        cache.set(idempotencyKey, timestampMs);
+}
+function maybePrune(filePath) {
+    try {
+        const { size } = statSync(filePath);
+        if (size <= MAX_BYTES)
+            return;
+        const lines = readFileSync(filePath, 'utf-8').trim().split('\n').filter(Boolean);
+        if (lines.length <= MAX_LINES)
+            return;
+        const cutoff = Date.now() - MAX_AGE_MS;
+        const kept = [];
+        for (const line of lines.slice(-MAX_LINES)) {
+            try {
+                const record = JSON.parse(line);
+                const ts = new Date(record.timestamp).getTime();
+                if (Number.isFinite(ts) && ts >= cutoff)
+                    kept.push(line);
+            }
+            catch { /* drop malformed */ }
+        }
+        writeFileSync(filePath, kept.join('\n') + (kept.length ? '\n' : ''));
+        // Cache is now stale w.r.t. dropped entries (older than dedup windows
+        // anyway), but rebuild lazily to avoid reading the file twice here.
+        dedupCache.delete(filePath);
+    }
+    catch {
+        // non-fatal
+    }
+}
+export function recordDecision(decision, context, opts) {
+    const now = opts?.now ?? new Date();
+    const record = {
+        id: hash(`${decision.idempotencyKey}:${now.toISOString()}:${context.signalType}`),
+        timestamp: now.toISOString(),
+        decision,
+        context,
+    };
+    const filePath = ledgerPath(opts);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    appendFileSync(filePath, JSON.stringify(record) + '\n');
+    touchDedupCache(filePath, decision.idempotencyKey, now.getTime());
+    setImmediate(() => maybePrune(filePath));
+    return record;
+}
+/**
+ * Append an outcome record. Event-sourced: outcomes are written as a NEW
+ * record sharing the original decision's `id`, not as in-place updates.
+ *
+ * `wasRecentlyDecided` therefore counts outcome records as "decided" — that
+ * is intentional. We don't want to re-act on a signal we've already handled,
+ * regardless of whether the latest entry is the original decision or its
+ * follow-up outcome.
+ */
+export function recordDecisionOutcome(decisionId, decision, context, outcome, opts) {
+    const now = opts?.now ?? new Date();
+    const record = {
+        id: decisionId,
+        timestamp: now.toISOString(),
+        decision,
+        context,
+        outcome: {
+            ...outcome,
+            recordedAt: now.toISOString(),
+        },
+    };
+    const filePath = ledgerPath(opts);
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    appendFileSync(filePath, JSON.stringify(record) + '\n');
+    touchDedupCache(filePath, decision.idempotencyKey, now.getTime());
+    setImmediate(() => maybePrune(filePath));
+    return record;
+}
+export function recentDecisions(filter = {}, opts) {
+    const filePath = ledgerPath(opts);
+    const nowMs = (opts?.now ?? new Date()).getTime();
+    return readRecords(filePath)
+        .filter((record) => {
+        if (filter.idempotencyKey && record.decision.idempotencyKey !== filter.idempotencyKey)
+            return false;
+        if (filter.action && record.decision.action !== filter.action)
+            return false;
+        if (filter.source && record.decision.source !== filter.source)
+            return false;
+        if (filter.sinceMs != null) {
+            const ts = new Date(record.timestamp).getTime();
+            if (!Number.isFinite(ts) || nowMs - ts > filter.sinceMs)
+                return false;
+        }
+        return true;
+    })
+        .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+}
+export function wasRecentlyDecided(idempotencyKey, windowMs, opts) {
+    const filePath = ledgerPath(opts);
+    const nowMs = (opts?.now ?? new Date()).getTime();
+    const cache = getDedupCache(filePath);
+    const latest = cache.get(idempotencyKey);
+    if (latest == null)
+        return false;
+    return nowMs - latest <= windowMs;
+}
+export function outcomeStatusFromGoalDisposition(disposition) {
+    switch (disposition) {
+        case 'advanced':
+            return 'advanced';
+        case 'blocked-on-user':
+            return 'blocked-on-user';
+        case 'blocked-on-external':
+            return 'blocked-on-external';
+        case 'needs-different-approach':
+            return 'needs-different-approach';
+        case 'monitoring':
+            return 'monitoring';
+        case 'no-change':
+            return 'no-change';
+        case 'error':
+        default:
+            return 'failed';
+    }
+}
+//# sourceMappingURL=proactive-ledger.js.map

package/dist/agent/self-improve.js

@@ -1792,11 +1792,9 @@ export function validateProposal(area, target, proposedChange) {
         if (SOURCE_BLOCKLIST.has(target)) {
             return { valid: false, error: `Source file '${target}' is in the blocklist and cannot be modified by self-improvement` };
         }
-        // Size sanity: reject wholesale rewrites (proposed content > 2x original would be caught by caller)
-        // Check basic TypeScript structure: must contain at least one import or export
-        if (!proposedChange.includes('import ') && !proposedChange.includes('export ')) {
-            return { valid: false, error: 'Source proposal missing import/export statements — likely not valid TypeScript' };
-        }
+        // Size sanity: reject wholesale rewrites (proposed content > 2x original would be caught by caller).
+        // Source proposals may be small patches or modules without import/export statements;
+        // callers that apply source changes do the syntax-aware validation.
     }
     return { valid: true };
 }

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

@@ -0,0 +1,42 @@
+/**
+ * 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 } from './agent-heartbeat-scheduler.js';
+export declare class AgentHeartbeatManager {
+    private readonly agentManager;
+    private readonly schedulers;
+    private timer;
+    private running;
+    private ticking;
+    constructor(agentManager: AgentManager);
+    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