clementine-agent 1.18.159 → 1.18.161

package/dist/agent/approval-signals.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Owner-approval feedback loop for self-improve proposals (1.18.161).
+ *
+ * Background: the self-improve hypothesizer generates 1-3 proposals each
+ * cycle. The owner approves or denies each one in the dashboard. Today
+ * that decision is recorded only as a status change on the experiment row
+ * — the *implicit signal* ("this kind of fix is good / bad") is lost.
+ *
+ * This module captures the signal as an append-only JSONL log
+ * (`~/.clementine/self-improve/approval-signals.jsonl`) and exposes
+ * `formatForHypothesizer()` so the next cycle's prompt includes:
+ *
+ *   ## Owner approval signals (recent)
+ *   APPROVED (do more like this):
+ *   - cron/insight-check: "Apply lean mode to reduce prompt size"
+ *   - agent/sasha-the-cmo: "Add explicit citation requirement to system prompt"
+ *
+ *   DENIED (avoid these patterns):
+ *   - workflow/email-gen: "Replace template with LLM generation"  ← user note: "too generic; loses voice"
+ *
+ * The hypothesizer reads this and biases future proposals — favoring
+ * patterns the owner has approved, avoiding patterns they've denied.
+ *
+ * Closed-loop autonomy: the system learns from human feedback without
+ * needing the human to write rules. Just react to proposals as usual.
+ */
+export interface ApprovalSignal {
+    /** ISO timestamp of the decision. */
+    ts: string;
+    /** Self-improve experiment ID this decision applies to. */
+    experimentId: string;
+    /** The area the proposal targeted (cron, agent, skill, soul, etc.). */
+    area: string;
+    /** The specific target (e.g., "insight-check", "sasha-the-cmo"). */
+    target: string;
+    /** The proposal's one-sentence hypothesis (truncated to 200 chars). */
+    hypothesis: string;
+    /** Owner's decision. */
+    decision: 'approved' | 'denied';
+    /** Optional free-text note from the owner explaining the decision. */
+    noteFromOwner?: string;
+}
+/** Append a new signal to the log. Best-effort — never throws to the caller. */
+export declare function recordApprovalSignal(signal: Omit<ApprovalSignal, 'ts'>): void;
+/**
+ * Read the most recent N signals from the log. Returns newest-first.
+ * Defaults to 50 — enough for the hypothesizer to see patterns, not so
+ * many that we bloat its prompt.
+ */
+export declare function getRecentApprovalSignals(limit?: number): ApprovalSignal[];
+/**
+ * Render a recent-signals prompt block for the hypothesizer. Returns the
+ * empty string when there are no signals (so the prompt stays clean for
+ * fresh installs). Caps at the most recent 8 of each kind to keep the
+ * block compact.
+ */
+export declare function formatApprovalSignalsForHypothesizer(): string;
+//# sourceMappingURL=approval-signals.d.ts.map

package/dist/agent/approval-signals.js

@@ -0,0 +1,105 @@
+/**
+ * Owner-approval feedback loop for self-improve proposals (1.18.161).
+ *
+ * Background: the self-improve hypothesizer generates 1-3 proposals each
+ * cycle. The owner approves or denies each one in the dashboard. Today
+ * that decision is recorded only as a status change on the experiment row
+ * — the *implicit signal* ("this kind of fix is good / bad") is lost.
+ *
+ * This module captures the signal as an append-only JSONL log
+ * (`~/.clementine/self-improve/approval-signals.jsonl`) and exposes
+ * `formatForHypothesizer()` so the next cycle's prompt includes:
+ *
+ *   ## Owner approval signals (recent)
+ *   APPROVED (do more like this):
+ *   - cron/insight-check: "Apply lean mode to reduce prompt size"
+ *   - agent/sasha-the-cmo: "Add explicit citation requirement to system prompt"
+ *
+ *   DENIED (avoid these patterns):
+ *   - workflow/email-gen: "Replace template with LLM generation"  ← user note: "too generic; loses voice"
+ *
+ * The hypothesizer reads this and biases future proposals — favoring
+ * patterns the owner has approved, avoiding patterns they've denied.
+ *
+ * Closed-loop autonomy: the system learns from human feedback without
+ * needing the human to write rules. Just react to proposals as usual.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { BASE_DIR } from '../config.js';
+/** Where the append-only signals log lives. */
+function signalsLogPath() {
+    return path.join(BASE_DIR, 'self-improve', 'approval-signals.jsonl');
+}
+/** Append a new signal to the log. Best-effort — never throws to the caller. */
+export function recordApprovalSignal(signal) {
+    try {
+        const file = signalsLogPath();
+        mkdirSync(path.dirname(file), { recursive: true });
+        const entry = {
+            ts: new Date().toISOString(),
+            ...signal,
+            // Truncate hypothesis to keep the log compact + searchable.
+            hypothesis: (signal.hypothesis || '').slice(0, 200),
+        };
+        appendFileSync(file, JSON.stringify(entry) + '\n');
+    }
+    catch { /* never block the apply/deny path on telemetry */ }
+}
+/**
+ * Read the most recent N signals from the log. Returns newest-first.
+ * Defaults to 50 — enough for the hypothesizer to see patterns, not so
+ * many that we bloat its prompt.
+ */
+export function getRecentApprovalSignals(limit = 50) {
+    const file = signalsLogPath();
+    if (!existsSync(file))
+        return [];
+    try {
+        const lines = readFileSync(file, 'utf-8').trim().split('\n').filter(Boolean);
+        const recent = [];
+        for (let i = lines.length - 1; i >= 0 && recent.length < limit; i--) {
+            try {
+                recent.push(JSON.parse(lines[i]));
+            }
+            catch { /* skip malformed lines */ }
+        }
+        return recent;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Render a recent-signals prompt block for the hypothesizer. Returns the
+ * empty string when there are no signals (so the prompt stays clean for
+ * fresh installs). Caps at the most recent 8 of each kind to keep the
+ * block compact.
+ */
+export function formatApprovalSignalsForHypothesizer() {
+    const signals = getRecentApprovalSignals(40);
+    if (signals.length === 0)
+        return '';
+    const approved = signals.filter(s => s.decision === 'approved').slice(0, 8);
+    const denied = signals.filter(s => s.decision === 'denied').slice(0, 8);
+    if (approved.length === 0 && denied.length === 0)
+        return '';
+    const fmt = (s) => {
+        const note = s.noteFromOwner ? `  ← owner note: "${s.noteFromOwner.slice(0, 120)}"` : '';
+        return `- ${s.area}/${s.target}: "${s.hypothesis}"${note}`;
+    };
+    const parts = ['### Owner approval signals (recent)'];
+    if (approved.length > 0) {
+        parts.push('APPROVED (do more like these):');
+        parts.push(approved.map(fmt).join('\n'));
+    }
+    if (denied.length > 0) {
+        parts.push('DENIED (avoid these patterns):');
+        parts.push(denied.map(fmt).join('\n'));
+    }
+    parts.push('Bias today\'s proposals toward the approved patterns and away from the denied ones. ' +
+        'If a denied pattern reflects a misunderstanding (e.g. you proposed the wrong target), ' +
+        'reframe — don\'t just avoid the area entirely.');
+    return parts.join('\n') + '\n\n';
+}
+//# sourceMappingURL=approval-signals.js.map

package/dist/agent/self-improve.d.ts

@@ -58,7 +58,7 @@ export declare class SelfImproveLoop {
     private savePendingChange;
     applyApprovedChange(experimentId: string): Promise<string>;
     /** Deny a pending change without applying it. */
-    denyChange(experimentId: string): string;
+    denyChange(experimentId: string, noteFromOwner?: string): string;
     private runMemoryCleanup;
     private synthesizeFeedbackPatterns;
     /** Update the structured user model from interaction data. */

package/dist/agent/self-improve.js

@@ -18,6 +18,7 @@ import { BASE_DIR, SELF_IMPROVE_DIR, SOUL_FILE, CRON_FILE, WORKFLOWS_DIR, VAULT_
 import { listAllGoals } from '../tools/shared.js';
 import { MemoryStore } from '../memory/store.js';
 import { ANTHROPIC_SKILL_NAME_PATTERN } from './skill-store.js';
+import { recordApprovalSignal, formatApprovalSignalsForHypothesizer } from './approval-signals.js';
 const logger = pino({ name: 'clementine.self-improve' });
 // ── Defaults ─────────────────────────────────────────────────────────
 const DEFAULT_CONFIG = {
@@ -1097,6 +1098,10 @@ export class SelfImproveLoop {
             }
         }
         catch { /* non-fatal */ }
+        // Owner-approval feedback (1.18.161) — bias hypotheses toward patterns the
+        // owner has approved, away from those they've denied. Empty string for
+        // fresh installs, which keeps the prompt clean.
+        const approvalSignalsText = formatApprovalSignalsForHypothesizer();
         // ── Step 1: Analysis — identify top opportunities from metrics (no config dumps) ──
         const analysisPrompt = `You are Clementine's self-improvement strategist. Analyze the performance data below and identify the top 3 improvement opportunities.\n\n` +
             `## Recent Performance Data (last 7 days)\n` +
@@ -1114,6 +1119,7 @@ export class SelfImproveLoop {
             diversityConstraint +
             agentFocusText +
             soulCandidatesText +
+            (approvalSignalsText ? `\n${approvalSignalsText}` : '') +
             `\n## Instructions\n` +
             `Propose **1-3 concrete, high-impact improvements** the owner should review today — no fewer (aim for at least one actionable suggestion when data warrants it), no more (the owner reads each proposal manually and you'll overwhelm them). Rank by expected impact; drop anything below "solid idea".\n\n` +
             `For each opportunity, specify:\n` +
@@ -1486,14 +1492,33 @@ export class SelfImproveLoop {
         catch (err) {
             logger.warn({ err }, 'Failed to schedule impact check');
         }
+        // 1.18.161 — record the implicit owner-approval signal so future
+        // hypothesizer cycles can see "the owner approved fixes like this"
+        // and bias proposals accordingly. Best-effort, never blocks apply.
+        recordApprovalSignal({
+            experimentId,
+            area: pending.area,
+            target: pending.target,
+            hypothesis: pending.hypothesis,
+            decision: 'approved',
+        });
         return `Applied change to ${pending.area}/${pending.target}`;
     }
     /** Deny a pending change without applying it. */
-    denyChange(experimentId) {
+    denyChange(experimentId, noteFromOwner) {
         const pendingFile = path.join(PENDING_DIR, `${experimentId}.json`);
         if (!existsSync(pendingFile)) {
             return `Pending change not found: ${experimentId}`;
         }
+        // 1.18.161 — capture the area/target/hypothesis BEFORE we delete the
+        // pending file so the approval-signal log gets a meaningful entry
+        // (not just an experiment ID with no context).
+        let signalContext = null;
+        try {
+            const pending = JSON.parse(readFileSync(pendingFile, 'utf-8'));
+            signalContext = { area: pending.area, target: pending.target, hypothesis: pending.hypothesis };
+        }
+        catch { /* file may be malformed; record a minimal signal below */ }
         this.updateExperimentStatus(experimentId, 'denied');
         try {
             unlinkSync(pendingFile);
@@ -1502,6 +1527,17 @@ export class SelfImproveLoop {
         const state = this.loadState();
         state.pendingApprovals = Math.max(0, state.pendingApprovals - 1);
         this.saveState(state);
+        // 1.18.161 — record the denial signal. Owner can pass an optional note
+        // (via the dashboard Reason field, or via Discord) explaining why so
+        // the hypothesizer learns more than just "no."
+        recordApprovalSignal({
+            experimentId,
+            area: signalContext?.area ?? 'unknown',
+            target: signalContext?.target ?? 'unknown',
+            hypothesis: signalContext?.hypothesis ?? '(pending file unreadable at deny time)',
+            decision: 'denied',
+            ...(noteFromOwner ? { noteFromOwner } : {}),
+        });
         return `Denied change: ${experimentId}`;
     }
     // ── Memory cleanup ───────────────────────────────────────────────

package/dist/cli/dashboard.js

@@ -21,7 +21,11 @@ import { discoverMcpServers, getClaudeIntegrations, KNOWN_MCP_DESCRIPTIONS } fro
 import { buildBuilderEnrichedMessage, builderSessionKey } from '../dashboard/builder/prompt.js';
 import { AGENTS_DIR, MEMORY_FILE, SESSIONS_FILE, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 import { parseTasks } from '../tools/shared.js';
-import { todayISO, CronRunLog } from '../gateway/cron-scheduler.js';
+// 1.18.160 — also pull parseCronJobs + parseAgentCronJobs so getCronJobs()
+// returns the same merged set the runtime fires (CRON.md + agent CRON +
+// schedule registry). Was reading only CRON.md before, hiding migrated
+// scheduled-skills from the Tasks tab while they kept firing on schedule.
+import { todayISO, CronRunLog, parseCronJobs, parseAgentCronJobs } from '../gateway/cron-scheduler.js';
 import { goalsRouter } from './routes/goals.js';
 import { delegationsRouter } from './routes/delegations.js';
 import { workflowsRouter } from './routes/workflows.js';
@@ -1270,43 +1274,29 @@ function getSessions() {
     }
 }
 function getCronJobs() {
-    let jobs = [];
-    // Load main CRON.md
-    if (existsSync(CRON_FILE)) {
-        try {
-            const raw = readFileSync(CRON_FILE, 'utf-8');
-            const parsed = matter(raw);
-            const mainJobs = (parsed.data.jobs ?? []);
-            jobs.push(...mainJobs);
-        }
-        catch { /* ignore */ }
-    }
-    // Load agent-scoped CRON.md files
-    const agentsDir = path.join(VAULT_DIR, '00-System', 'agents');
-    if (existsSync(agentsDir)) {
-        try {
-            for (const slug of readdirSync(agentsDir)) {
-                const agentCronFile = path.join(agentsDir, slug, 'CRON.md');
-                if (!existsSync(agentCronFile))
-                    continue;
-                try {
-                    const raw = readFileSync(agentCronFile, 'utf-8');
-                    const parsed = matter(raw);
-                    const agentJobs = (parsed.data.jobs ?? []);
-                    for (const job of agentJobs) {
-                        jobs.push({ ...job, agent: slug, name: `${slug}:${job.name}` });
-                    }
-                }
-                catch { /* ignore individual agent parse errors */ }
-            }
-        }
-        catch { /* ignore */ }
-    }
+    // 1.18.160 — delegate to the canonical merger so scheduled-skill rows
+    // (from ~/.clementine/schedules.json) reach the dashboard alongside
+    // legacy CRON.md entries. Before this, getCronJobs() only read CRON.md
+    // — so when a user migrated 14 of their 15 crons to scheduled-skills,
+    // the Tasks page silently dropped to 1 card while the runtime kept
+    // firing all 22 jobs. The result LOOKED like a regression because the
+    // user couldn't see, edit, pause, or trace any of the migrated work
+    // from the Tasks tab. parseCronJobs() reads BOTH CRON.md + agent CRON
+    // files + the schedule registry, dedups by name (scheduled-skill wins
+    // collisions), and stamps `source` so the existing card renderer can
+    // branch on SKILL vs LEGACY CRON badge.
+    //
+    // The dashboard now sees exactly what the runtime fires — single
+    // source of truth, no drift. Both helpers are imported at the top.
+    const allJobs = [
+        ...parseCronJobs(),
+        ...parseAgentCronJobs(path.join(VAULT_DIR, '00-System', 'agents')),
+    ];
     // Attach recent run history. Single source of truth via CronRunLog.readRecent
     // — same path the new /api/cron/runs cross-job endpoint uses, so per-card
     // last-run and the Recent History zone never disagree.
     const log = new CronRunLog();
-    const enriched = jobs.map((job) => {
+    const enriched = allJobs.map((job) => {
         const name = String(job.name ?? '');
         const recentRuns = log.readRecent(name, 10);
         return { ...job, recentRuns };
@@ -11512,7 +11502,14 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
     app.post('/api/self-improve/deny/:id', async (req, res) => {
         try {
             const gw = await getGateway();
-            const result = await gw.handleSelfImprove('deny', { experimentId: req.params.id });
+            // 1.18.161 — accept an optional `noteFromOwner` in the body so the
+            // approval-signal log captures the *reason* for denial (the
+            // hypothesizer learns more from "too generic — loses voice" than
+            // from a bare "no").
+            const noteFromOwner = typeof req.body?.noteFromOwner === 'string'
+                ? req.body.noteFromOwner.slice(0, 500)
+                : undefined;
+            const result = await gw.handleSelfImprove('deny', { experimentId: req.params.id, noteFromOwner });
             res.json({ ok: true, message: result });
         }
         catch (err) {
@@ -27344,15 +27341,29 @@ async function refreshCron() {
     // (definition.source !== 'scheduled-skill') and surfaces a one-click
     // bulk migrator. Dismissable; persists in localStorage so it doesn't
     // nag on every refresh.
+    // 1.18.160 — only nag for UNHEALTHY legacy crons. After the user
+    // bulk-migrates 14 healthy ones, having a banner shout about the
+    // 1 healthy survivor felt naggy. The user can still migrate healthy
+    // ones at their leisure via per-row "→ Skill" buttons; the banner
+    // earns the screen real estate only when there's a real problem.
     var legacyCount = 0;
+    var legacyUnhealthyCount = 0;
     try {
-      legacyCount = (visibleTasks || []).filter(function(t) {
+      var legacyRows = (visibleTasks || []).filter(function(t) {
         return !(t.definition && t.definition.source === 'scheduled-skill');
+      });
+      legacyCount = legacyRows.length;
+      legacyUnhealthyCount = legacyRows.filter(function(t) {
+        var h = t.health;
+        return h === 'failed' || h === 'broken' || h === 'never_run';
       }).length;
     } catch (_) { /* defensive */ }
     var bannerHtml = '';
     var dismissed = localStorage.getItem('clem-skill-migrate-banner-dismissed') === '1';
-    if (legacyCount > 0 && !dismissed) {
+    // Show the banner only when there's an unhealthy legacy cron to nudge
+    // the user about. Healthy legacy crons live quietly until the user
+    // chooses to migrate them per-row.
+    if (legacyUnhealthyCount > 0 && !dismissed) {
       // 1.18.155 — data-banner-kind tags this as the legacy-cron soft-
       // deprecation banner so refreshCronMigrateBanner can suppress its
       // secondary "clean up preambles" banner when this one is showing
@@ -27360,8 +27371,8 @@ async function refreshCron() {
       bannerHtml = '<div data-banner-kind="legacy-cron-soft-deprecation" style="background:rgba(124,58,237,0.08);border:1px solid var(--purple);border-radius:8px;padding:12px 14px;margin-bottom:14px;display:flex;align-items:center;gap:12px;flex-wrap:wrap">'
         + '<span style="font-size:18px">⚡</span>'
         + '<div style="flex:1;min-width:200px">'
-        +   '<div style="font-size:13px;font-weight:500;color:var(--text-primary)">' + legacyCount + ' legacy cron task' + (legacyCount === 1 ? '' : 's') + ' can become scheduled skills</div>'
-        +   '<div style="font-size:11px;color:var(--text-muted);margin-top:2px">Skills are the Anthropic-pure unit of work. Scheduled-skill format is thinner, easier to maintain, and tasks can be reused on demand.</div>'
+        +   '<div style="font-size:13px;font-weight:500;color:var(--text-primary)">' + legacyUnhealthyCount + ' legacy cron task' + (legacyUnhealthyCount === 1 ? '' : 's') + ' failing — migrating to a scheduled skill often clears the issue</div>'
+        +   '<div style="font-size:11px;color:var(--text-muted);margin-top:2px">Scheduled skills use a tighter context envelope (lean mode for meta-jobs) and the Anthropic-canonical SKILL.md format. Healthy legacy crons stay quietly out of the way.</div>'
         + '</div>'
         + '<button class="btn-sm btn-primary" onclick="migrateAllCronsToSkills()" style="font-size:12px;padding:6px 12px">Migrate all eligible →</button>'
         + '<button class="btn-sm" onclick="localStorage.setItem(\\x27clem-skill-migrate-banner-dismissed\\x27,\\x271\\x27);refreshCron()" title="Hide this banner" style="font-size:12px;padding:6px 10px">Dismiss</button>'
@@ -40683,7 +40694,17 @@ async function siApply(id) {
 
 async function siDeny(id) {
   try {
-    const r = await apiFetch('/api/self-improve/deny/' + id, { method: 'POST' });
+    // 1.18.161 — invite an optional one-line reason. Cancel = bare deny;
+    // empty string = bare deny; non-empty = sent to the hypothesizer's
+    // approval-signal log so future cycles avoid the rejected pattern.
+    const note = window.prompt('Optional reason for denying (helps the hypothesizer learn — leave blank to skip):', '');
+    if (note === null) return;
+    const body = note.trim() ? JSON.stringify({ noteFromOwner: note.trim() }) : undefined;
+    const r = await apiFetch('/api/self-improve/deny/' + id, {
+      method: 'POST',
+      headers: body ? { 'Content-Type': 'application/json' } : undefined,
+      body,
+    });
     const d = await r.json();
     if (d.ok) toast(d.message, 'success');
     else toast(d.message || 'Failed', 'error');

package/dist/gateway/router.d.ts

@@ -308,6 +308,7 @@ export declare class Gateway {
     getAllProvenance(): Map<string, SessionProvenance>;
     handleSelfImprove(action: string, args?: {
         experimentId?: string;
+        noteFromOwner?: string;
         config?: Partial<SelfImproveConfig>;
     }, onProposal?: (experiment: SelfImproveExperiment) => Promise<void>): Promise<string>;
     /** Extract a procedural skill from a successful cron execution (fire-and-forget). */

package/dist/gateway/router.js

@@ -2437,7 +2437,7 @@ export class Gateway {
                 case 'deny': {
                     if (!args?.experimentId)
                         return 'Missing experiment ID.';
-                    return loop.denyChange(args.experimentId);
+                    return loop.denyChange(args.experimentId, args.noteFromOwner);
                 }
                 case 'run-agent': {
                     const slug = args?.experimentId; // Reuse experimentId field for agent slug

package/package.json

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