clementine-agent 1.0.75 → 1.0.77

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/cli/dashboard.js

@@ -12380,14 +12380,24 @@ async function checkAnthropicAuth() {
     var btn = document.getElementById('gs-auth-btn');
     if (d.authenticated && card) {
       card.className = 'gs-card gs-done';
-      if (desc) desc.textContent = 'Connected as ' + d.email;
+      // Email is null when auth comes from the Claude Code keychain (OAuth
+      // login via clementine-login or claude-login that we do not have read
+      // access to). Avoid rendering "Connected as null" — looks broken and
+      // makes users re-click login, which hits an SDK bug in claudeAuthenticate.
+      var label = d.email
+        ? 'Connected as ' + d.email
+        : 'Connected via ' + (d.apiKeySource === 'keychain' ? 'Claude Code keychain' : d.apiKeySource || 'API');
+      if (desc) desc.textContent = label;
       if (btn) { btn.textContent = 'Connected'; btn.disabled = true; }
     }
     // Also update settings auth indicator
     var settingsAuth = document.getElementById('settings-auth-status');
     if (settingsAuth) {
+      var sLabel = d.authenticated
+        ? (d.email ? 'Connected as ' + d.email : 'Connected via ' + (d.apiKeySource || 'API'))
+        : '';
       settingsAuth.innerHTML = d.authenticated
-        ? '<span style="color:var(--green)">Connected as ' + d.email + '</span>'
+        ? '<span style="color:var(--green)">' + sLabel + '</span>'
         : '<span style="color:var(--text-muted)">Not connected</span>';
     }
     return d;
@@ -12397,6 +12407,23 @@ async function checkAnthropicAuth() {
 async function startAnthropicOAuth() {
   var btn = document.getElementById('gs-auth-btn');
   var desc = document.getElementById('gs-auth-desc');
+  // Precheck: if the user is already authenticated (env var or keychain),
+  // don't trigger the SDK OAuth flow — which has an upstream bug where
+  // claudeAuthenticate sends a malformed Messages API request with
+  // cache_control on an empty text block (HTTP 400).
+  try {
+    var statusResp = await apiFetch('/api/auth/anthropic/status');
+    var statusData = await statusResp.json();
+    if (statusData && statusData.authenticated) {
+      var card = document.getElementById('gs-step-auth');
+      if (card) card.className = 'gs-card gs-done';
+      if (desc) desc.textContent = statusData.email
+        ? 'Connected as ' + statusData.email
+        : 'Already connected via ' + (statusData.apiKeySource || 'API') + ' — no login needed';
+      if (btn) { btn.textContent = 'Connected'; btn.disabled = true; }
+      return;
+    }
+  } catch (_) { /* fall through to real login */ }
   if (btn) { btn.textContent = 'Opening login...'; btn.disabled = true; }
   try {
     var r = await apiFetch('/api/auth/anthropic/login', { method: 'POST' });
@@ -12417,7 +12444,15 @@ async function startAnthropicOAuth() {
       throw new Error(wd.error || 'Login did not complete');
     }
   } catch (err) {
-    if (desc) desc.textContent = 'Login failed: ' + err.message;
+    // Special case: the SDK's claudeAuthenticate has a known bug where it
+    // sends malformed API payloads ("cache_control cannot be set for empty
+    // text blocks"). If that fires, point the user at the CLI login path.
+    var msg = err && err.message ? err.message : String(err);
+    if (/cache_control.+empty text blocks/i.test(msg)) {
+      if (desc) desc.textContent = 'In-browser login hit a known SDK bug. Run "clementine login" in your terminal instead, or check if you are already logged in — the daemon only needs to start once.';
+    } else {
+      if (desc) desc.textContent = 'Login failed: ' + msg;
+    }
     if (btn) { btn.textContent = 'Retry Login'; btn.disabled = false; }
   }
 }

package/dist/gateway/cron-scheduler.d.ts

@@ -159,6 +159,7 @@ export declare class CronScheduler {
      * Creates the causal link: "action X was attempted for goal Y, result was Z."
      */
     private logGoalOutcome;
+    private logProactiveDecisionOutcome;
     /**
      * Apply non-destructive cron changes suggested by the daily planner.
      * Only auto-applies suggestions that reference a high-priority goal with autoSchedule=true.

package/dist/gateway/cron-scheduler.js

@@ -18,6 +18,7 @@ import { scanner } from '../security/scanner.js';
 import { parseAllWorkflows as parseAllWorkflowsSync } from '../agent/workflow-runner.js';
 import { SelfImproveLoop } from '../agent/self-improve.js';
 import { logAuditJsonl } from '../agent/hooks.js';
+import { outcomeStatusFromGoalDisposition, recentDecisions, recordDecisionOutcome, } from '../agent/proactive-ledger.js';
 const logger = pino({ name: 'clementine.cron' });
 /** Default timeout for standard cron jobs (10 minutes). */
 const CRON_STANDARD_TIMEOUT_MS = 10 * 60 * 1000;
@@ -1643,7 +1644,7 @@ export class CronScheduler {
                     const advice = getExecutionAdvice(jobName, syntheticJob);
                     if (advice.shouldSkip) {
                         logger.info({ goalId: trigger.goalId, reason: advice.skipReason }, 'Goal work skipped by advisor (circuit breaker)');
-                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, null, `Skipped: ${advice.skipReason}`);
+                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source ?? 'unknown', null, `Skipped: ${advice.skipReason}`, trigger.decision);
                         return;
                     }
                     const effectiveMaxTurns = advice.adjustedMaxTurns ?? syntheticJob.maxTurns ?? 15;
@@ -1667,10 +1668,10 @@ export class CronScheduler {
                             this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`, dispatchOpts).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
                         }
                         logToDailyNote(`**Goal work: ${goal.title}** — ${(result || 'completed').slice(0, 100).replace(/\n/g, ' ')}`);
-                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, result);
+                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source ?? 'unknown', result, undefined, trigger.decision);
                     }).catch((err) => {
                         logger.error({ err, goalId: trigger.goalId }, 'Goal work session failed');
-                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, null, String(err));
+                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source ?? 'unknown', null, String(err), trigger.decision);
                     });
                 }).catch((err) => {
                     // Advisor import failed — fall back to basic execution
@@ -1686,10 +1687,10 @@ export class CronScheduler {
                             this.dispatcher.send(`🎯 **Goal work: ${goal.title}**\n\n${result.slice(0, 1500)}`, dispatchOpts).catch(err => logger.debug({ err }, 'Failed to send goal work notification'));
                         }
                         logToDailyNote(`**Goal work: ${goal.title}** — ${(result || 'completed').slice(0, 100).replace(/\n/g, ' ')}`);
-                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, result);
+                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source ?? 'unknown', result, undefined, trigger.decision);
                     }).catch((goalErr) => {
                         logger.error({ err: goalErr, goalId: trigger.goalId }, 'Goal work session failed');
-                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source, null, String(goalErr));
+                        this.logGoalOutcome(trigger.goalId, goalPath, goalSnapshotUpdatedAt, goalSnapshotNotes, trigger.focus, trigger.source ?? 'unknown', null, String(goalErr), trigger.decision);
                     });
                 });
             }
@@ -1706,7 +1707,7 @@ export class CronScheduler {
      * Log goal work session outcome to a per-goal progress JSONL file.
      * Creates the causal link: "action X was attempted for goal Y, result was Z."
      */
-    logGoalOutcome(goalId, goalPath, prevUpdatedAt, prevNotesCount, focus, source, result, error) {
+    logGoalOutcome(goalId, goalPath, prevUpdatedAt, prevNotesCount, focus, source, result, error, proactiveDecision) {
         try {
             let madeProgress = false;
             let newNotesCount = prevNotesCount;
@@ -1738,12 +1739,46 @@ export class CronScheduler {
             mkdirSync(progressDir, { recursive: true });
             const progressFile = path.join(progressDir, `${goalId}.progress.jsonl`);
             appendFileSync(progressFile, JSON.stringify(entry) + '\n');
+            if (proactiveDecision) {
+                this.logProactiveDecisionOutcome(proactiveDecision, {
+                    goalId,
+                    focus,
+                    source,
+                    disposition,
+                    madeProgress,
+                    resultSnippet: entry.resultSnippet,
+                    newProgressNotes: entry.newProgressNotes,
+                });
+            }
             logger.info({ goalId, madeProgress, disposition, status: entry.status }, 'Goal outcome logged');
         }
         catch (err) {
             logger.debug({ err, goalId }, 'Failed to log goal outcome (non-fatal)');
         }
     }
+    logProactiveDecisionOutcome(decision, details) {
+        try {
+            const existing = recentDecisions({ idempotencyKey: decision.idempotencyKey }, undefined)[0];
+            const decisionId = existing?.id ?? decision.idempotencyKey;
+            recordDecisionOutcome(decisionId, decision, {
+                signalType: 'goal-work-outcome',
+                description: details.focus,
+                goalId: details.goalId,
+                metadata: {
+                    source: details.source,
+                    disposition: details.disposition,
+                    madeProgress: details.madeProgress,
+                    newProgressNotes: details.newProgressNotes,
+                },
+            }, {
+                status: outcomeStatusFromGoalDisposition(details.disposition),
+                summary: details.resultSnippet || details.disposition,
+            });
+        }
+        catch (err) {
+            logger.debug({ err, goalId: details.goalId }, 'Failed to log proactive decision outcome (non-fatal)');
+        }
+    }
     /**
      * Apply non-destructive cron changes suggested by the daily planner.
      * Only auto-applies suggestions that reference a high-priority goal with autoSchedule=true.

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

@@ -93,10 +93,12 @@ export declare class HeartbeatScheduler {
     private claimNextItem;
     private completeItem;
     private failItem;
+    private recordWorkItemOutcome;
     static enqueueWork(opts: {
         description: string;
         prompt: string;
         source: string;
+        idempotencyKey?: string;
         priority?: 'high' | 'normal';
         maxTurns?: number;
         tier?: number;

package/dist/gateway/heartbeat-scheduler.js

@@ -12,8 +12,11 @@ import pino from 'pino';
 import { HEARTBEAT_FILE, TASKS_FILE, INBOX_DIR, DAILY_NOTES_DIR, HEARTBEAT_INTERVAL_MINUTES, HEARTBEAT_ACTIVE_START, HEARTBEAT_ACTIVE_END, BASE_DIR, GOALS_DIR, HEARTBEAT_WORK_QUEUE_FILE, DISCORD_OWNER_ID, } from '../config.js';
 import { listAllGoals } from '../tools/shared.js';
 import { gatherInsightSignals, buildInsightPrompt, parseInsightResponse, canSendInsight, recordInsightSent, recordInsightAcked, maybeIncreaseCooldown, } from '../agent/insight-engine.js';
+import { 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,18 +436,13 @@ 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)
-                        continue;
-                    // Skip if already queued
-                    if (pendingDescriptions.has(priority.action))
+                    const decision = decideDailyPlanPriority({ priority, date: todayPlan.date });
+                    if (priority.type !== 'goal' || !decisionShouldQueueHeartbeatWork(decision))
                         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 (wasRecentlyDecided(decision.idempotencyKey, PROACTIVE_DECISION_DEDUPE_MS))
                         continue;
                     HeartbeatScheduler.enqueueWork({
                         description: priority.action,
@@ -409,10 +450,17 @@ export class HeartbeatScheduler {
                             `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 +480,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 +957,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 +1049,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 +1110,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 +1134,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 +1144,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 +1189,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 {
@@ -1188,6 +1251,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 +1269,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 +1430,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/tools/session-tools.js

@@ -5,6 +5,15 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import path from 'node:path';
 import { z } from 'zod';
 import { BASE_DIR, HANDOFFS_DIR, INBOX_DIR, TASKS_FILE, logger, textResult, todayStr, listAllGoals, } from './shared.js';
+import { decideDiscoveredWorkItem } from '../agent/proactive-engine.js';
+import { recentDecisions } from '../agent/proactive-ledger.js';
+const ACTION_LABEL = {
+    act_now: 'Doing now',
+    queue: 'Queued',
+    ask_user: 'Needs you',
+    snooze: 'Snoozed',
+    ignore: 'Skipped',
+};
 function ensureHandoffsDir() {
     if (!existsSync(HANDOFFS_DIR))
         mkdirSync(HANDOFFS_DIR, { recursive: true });
@@ -78,7 +87,7 @@ export function registerSessionTools(server) {
             const staleThreshold = goal.reviewFrequency === 'daily' ? 1 : goal.reviewFrequency === 'weekly' ? 7 : 30;
             if (daysSinceUpdate > staleThreshold) {
                 const urgency = Math.min(5, Math.floor(daysSinceUpdate / staleThreshold) + (goal.priority === 'high' ? 2 : goal.priority === 'medium' ? 1 : 0));
-                items.push({ type: 'stale-goal', urgency, description: `Goal "${goal.title}" stale for ${daysSinceUpdate}d (${goal.priority} priority)` });
+                items.push({ type: 'stale-goal', id: goal.id, urgency, description: `Goal "${goal.title}" stale for ${daysSinceUpdate}d (${goal.priority} priority)` });
             }
         }
         // 2. Failing cron jobs
@@ -92,7 +101,7 @@ export function registerSessionTools(server) {
                     const errCount = consecutiveErrors === -1 ? recent.length : consecutiveErrors;
                     if (errCount >= 2) {
                         const jobName = recent[0]?.jobName ?? f.replace('.jsonl', '');
-                        items.push({ type: 'cron-failure', urgency: Math.min(5, errCount), description: `Job "${jobName}" has ${errCount} consecutive failures` });
+                        items.push({ type: 'cron-failure', id: jobName, urgency: Math.min(5, errCount), description: `Job "${jobName}" has ${errCount} consecutive failures` });
                     }
                 }
                 catch {
@@ -107,13 +116,13 @@ export function registerSessionTools(server) {
             const overdue = (content.match(/- \[ \].*?📅\s*(\d{4}-\d{2}-\d{2})/g) ?? [])
                 .filter(line => { const m = line.match(/📅\s*(\d{4}-\d{2}-\d{2})/); return m && m[1] < today; });
             if (overdue.length > 0)
-                items.push({ type: 'overdue-tasks', urgency: 4, description: `${overdue.length} overdue task(s) in TASKS.md` });
+                items.push({ type: 'overdue-tasks', id: 'tasks-overdue', urgency: 4, description: `${overdue.length} overdue task(s) in TASKS.md` });
         }
         // 4. Inbox items
         if (existsSync(INBOX_DIR)) {
             const inboxFiles = readdirSync(INBOX_DIR).filter(f => f.endsWith('.md') && !f.startsWith('_'));
             if (inboxFiles.length > 0)
-                items.push({ type: 'inbox', urgency: 2, description: `${inboxFiles.length} unprocessed inbox item(s)` });
+                items.push({ type: 'inbox', id: 'inbox', urgency: 2, description: `${inboxFiles.length} unprocessed inbox item(s)` });
         }
         // 5. Daily plan priorities
         const planFile = path.join(BASE_DIR, 'plans', 'daily', `${todayStr()}.json`);
@@ -123,7 +132,7 @@ export function registerSessionTools(server) {
                 for (const p of (plan.priorities ?? []).slice(0, 5)) {
                     const alreadyListed = items.some(i => i.description.includes(p.id) || i.description.includes(p.action?.slice(0, 20)));
                     if (!alreadyListed)
-                        items.push({ type: `plan-${p.type}`, urgency: p.urgency ?? 3, description: `[From daily plan] ${p.action}` });
+                        items.push({ type: `plan-${p.type}`, id: p.id, urgency: p.urgency ?? 3, description: `[From daily plan] ${p.action}` });
                 }
             }
             catch { /* non-fatal */ }
@@ -132,8 +141,51 @@ 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.');
-        const lines = topItems.map(i => `- [${i.type}] Urgency ${i.urgency}/5: ${i.description}`);
+        const lines = topItems.map((i) => {
+            const decision = decideDiscoveredWorkItem(i);
+            const label = ACTION_LABEL[decision.action];
+            return `- [${i.type}] Urgency ${i.urgency}/5 → ${label}: ${i.description}`;
+        });
         return textResult(`## Discovered Work Items (${topItems.length})\n${lines.join('\n')}`);
     });
+    server.tool('proactive_stats', 'Report how the proactive engine has been deciding and what those decisions led to. Use to tune urgency thresholds.', {
+        since_hours: z.number().optional().describe('Window in hours (default: 168 = 7 days)'),
+    }, async ({ since_hours }) => {
+        const windowMs = (since_hours ?? 168) * 60 * 60 * 1000;
+        const records = recentDecisions({ sinceMs: windowMs }, undefined);
+        if (records.length === 0)
+            return textResult('No proactive decisions recorded in window.');
+        const bySource = new Map();
+        const outcomeByKey = new Map();
+        for (const r of records) {
+            if (r.outcome)
+                outcomeByKey.set(r.decision.idempotencyKey, r.outcome.status);
+        }
+        for (const r of records) {
+            if (r.outcome)
+                continue;
+            const sourceMap = bySource.get(r.decision.source) ?? new Map();
+            const bucket = sourceMap.get(r.decision.action) ?? { decided: 0, outcomes: {} };
+            bucket.decided++;
+            const outcome = outcomeByKey.get(r.decision.idempotencyKey);
+            if (outcome)
+                bucket.outcomes[outcome] = (bucket.outcomes[outcome] ?? 0) + 1;
+            sourceMap.set(r.decision.action, bucket);
+            bySource.set(r.decision.source, sourceMap);
+        }
+        const lines = [`## Proactive Stats (last ${since_hours ?? 168}h, ${records.length} records)\n`];
+        for (const [source, actionMap] of bySource) {
+            lines.push(`### ${source}`);
+            for (const [action, bucket] of actionMap) {
+                const outcomes = Object.entries(bucket.outcomes);
+                const outcomeStr = outcomes.length === 0
+                    ? 'no outcomes recorded'
+                    : outcomes.map(([k, v]) => `${k}=${v}`).join(', ');
+                lines.push(`- ${ACTION_LABEL[action]} (${action}): decided ${bucket.decided}× → ${outcomeStr}`);
+            }
+            lines.push('');
+        }
+        return textResult(lines.join('\n'));
+    });
 }
 //# sourceMappingURL=session-tools.js.map

package/dist/types.d.ts

@@ -210,6 +210,7 @@ export interface HeartbeatWorkItem {
     description: string;
     prompt: string;
     source: string;
+    idempotencyKey?: string;
     priority: 'high' | 'normal';
     queuedAt: string;
     maxTurns: number;

package/package.json

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