clementine-agent 1.18.160 → 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

@@ -11502,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) {
@@ -40687,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.160",
+  "version": "1.18.161",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",