prism-mcp-server 8.0.2 → 9.0.4

package/dist/storage/sqlite.js

@@ -21,7 +21,7 @@ import * as path from "path";
 import * as os from "os";
 import { randomUUID } from "crypto";
 import { AccessLogBuffer } from "../utils/accessLogBuffer.js";
-import { PRISM_ACTR_BUFFER_FLUSH_MS, PRISM_SYNAPSE_ENABLED, PRISM_SYNAPSE_ITERATIONS, PRISM_SYNAPSE_SPREAD_FACTOR, PRISM_SYNAPSE_LATERAL_INHIBITION, PRISM_SYNAPSE_SOFT_CAP, } from "../config.js";
+import { PRISM_ACTR_BUFFER_FLUSH_MS, PRISM_SYNAPSE_ENABLED, PRISM_SYNAPSE_ITERATIONS, PRISM_SYNAPSE_SPREAD_FACTOR, PRISM_SYNAPSE_LATERAL_INHIBITION, PRISM_SYNAPSE_SOFT_CAP, PRISM_VALENCE_ENABLED, } from "../config.js";
 import { getSetting as cfgGet, setSetting as cfgSet, getAllSettings as cfgGetAll } from "./configStorage.js";
 import { debugLog } from "../utils/logger.js";
 import { SafetyController } from "../darkfactory/safetyController.js";
@@ -108,7 +108,8 @@ export class SqliteStorage {
         rollup_count INTEGER DEFAULT 0,
         archived_at TEXT DEFAULT NULL,
         session_date TEXT DEFAULT NULL,
-        created_at TEXT DEFAULT (datetime('now'))
+        created_at TEXT DEFAULT (datetime('now')),
+        valence REAL DEFAULT NULL
       );
 
       -- ─── Session Handoffs (live project state, OCC-controlled) ───
@@ -123,6 +124,7 @@ export class SqliteStorage {
         key_context TEXT DEFAULT NULL,
         active_branch TEXT DEFAULT NULL,
         version INTEGER NOT NULL DEFAULT 1,
+        cognitive_budget REAL DEFAULT NULL,
         metadata TEXT DEFAULT '{}',
         created_at TEXT DEFAULT (datetime('now')),
         updated_at TEXT DEFAULT (datetime('now')),
@@ -166,7 +168,7 @@ export class SqliteStorage {
         VALUES ('delete', old.rowid, old.project, old.summary, old.decisions, old.keywords);
       END;
 
-      CREATE TRIGGER IF NOT EXISTS ledger_fts_update AFTER UPDATE ON session_ledger BEGIN
+      CREATE TRIGGER IF NOT EXISTS ledger_fts_update AFTER UPDATE OF project, summary, decisions, keywords ON session_ledger BEGIN
         INSERT INTO ledger_fts(ledger_fts, rowid, project, summary, decisions, keywords)
         VALUES ('delete', old.rowid, old.project, old.summary, old.decisions, old.keywords);
         INSERT INTO ledger_fts(rowid, project, summary, decisions, keywords)
@@ -725,6 +727,36 @@ export class SqliteStorage {
             // Non-fatal: some older libSQL versions may not support all integrity_check modes.
             debugLog(`[SqliteStorage] v6.1: integrity_check skipped (${e.message})`);
         }
+        // ─── v9.0 Migration: Affect-Tagged Memory (Valence) ───────────
+        //
+        // Adds a REAL valence column to session_ledger for affect-tagged memory.
+        // Valence is auto-derived from event_type at save time.
+        // Uses Affective Salience: |valence| boosts retrieval, sign drives UX warnings.
+        // For fresh DBs, valence is already in the CREATE TABLE. This ALTER TABLE
+        // is purely for existing production databases upgrading from v8.x → v9.0.
+        try {
+            await this.db.execute(`ALTER TABLE session_ledger ADD COLUMN valence REAL DEFAULT NULL`);
+            debugLog("[SqliteStorage] v9.0 migration: added valence column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
+        // Partial index for valence-aware queries (schema parity with Supabase)
+        await this.db.execute(`CREATE INDEX IF NOT EXISTS idx_ledger_valence ON session_ledger(valence) WHERE valence IS NOT NULL`);
+        // ─── v9.0 Migration: Persistent Cognitive Budget ──────────────
+        //
+        // Budget belongs to the PROJECT (stored in session_handoffs), not
+        // the ephemeral session, to prevent the "Reset Exploit" where an
+        // agent escapes budget exhaustion by simply starting a new session.
+        try {
+            await this.db.execute(`ALTER TABLE session_handoffs ADD COLUMN cognitive_budget REAL DEFAULT NULL`);
+            debugLog("[SqliteStorage] v9.0 migration: added cognitive_budget column");
+        }
+        catch (e) {
+            if (!e.message?.includes("duplicate column name"))
+                throw e;
+        }
     }
     // ─── PostgREST Filter Parser ───────────────────────────────
     //
@@ -896,10 +928,10 @@ export class SqliteStorage {
             sql: `INSERT INTO session_ledger
         (id, project, conversation_id, user_id, role, summary, todos, files_changed,
          decisions, keywords, is_rollup, rollup_count, title, agent_name,
-         event_type, confidence_score, importance,
+         event_type, confidence_score, importance, valence,
          embedding_compressed, embedding_format, embedding_turbo_radius,
          created_at, session_date)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
             args: [
                 id,
                 entry.project,
@@ -918,6 +950,7 @@ export class SqliteStorage {
                 entry.event_type || "session", // v4.0: default to 'session'
                 entry.confidence_score ?? null, // v4.0: nullable
                 entry.importance || 0, // v4.0: default to 0
+                entry.valence ?? null, // v9.0: affect-tagged memory
                 entry.embedding_compressed || null, // v5.0: TurboQuant
                 entry.embedding_format || null, // v5.0: turbo3/turbo4/float32
                 entry.embedding_turbo_radius ?? null, // v5.0: original vector magnitude
@@ -950,7 +983,7 @@ export class SqliteStorage {
             'embedding', 'embedding_compressed', 'embedding_format', 'embedding_turbo_radius',
             'archived_at', 'deleted_at', 'deleted_reason', 'is_rollup', 'rollup_count',
             'importance', 'last_accessed_at', 'keywords', 'todos', 'files_changed', 'decisions',
-            'summary', 'confidence_score', 'event_type', 'role',
+            'summary', 'confidence_score', 'event_type', 'role', 'valence',
         ]);
         const sets = [];
         const args = [];
@@ -978,6 +1011,18 @@ export class SqliteStorage {
             args,
         });
     }
+    // ─── v9.0: Atomic delta-based budget persistence ────────────────
+    // Uses COALESCE + delta to prevent concurrency race conditions:
+    //   Agent A loads budget=2000, spends 100 → delta=-100
+    //   Agent B loads budget=2000, spends 50  → delta=-50
+    // With absolute writes: Agent B overwrites Agent A's spend (budget=1950)
+    // With delta: Both apply correctly → budget=2000 + (-100) + (-50) = 1850
+    async patchHandoffBudgetDelta(project, userId, budgetDelta) {
+        await this.db.execute({
+            sql: `UPDATE session_handoffs SET cognitive_budget = MAX(0, COALESCE(cognitive_budget, 2000) + ?) WHERE project = ? AND user_id = ?`,
+            args: [budgetDelta, project, userId],
+        });
+    }
     async getLedgerEntries(params) {
         const { ids, ...restParams } = params;
         const { where, args, select, order, limit } = this.parsePostgRESTFilters(restParams);
@@ -1492,6 +1537,7 @@ export class SqliteStorage {
             const sql = `
         SELECT l.id, l.project, l.summary, l.decisions, l.files_changed,
                l.session_date, l.created_at, l.is_rollup, l.importance, l.last_accessed_at,
+               l.valence,
                (1 - vector_distance_cos(l.embedding, vector(?))) AS similarity
         FROM session_ledger l
         WHERE ${conditions.join(" AND ")}
@@ -1513,6 +1559,7 @@ export class SqliteStorage {
                 is_rollup: Boolean(r.is_rollup),
                 importance: r.importance ?? 0,
                 last_accessed_at: r.last_accessed_at || null,
+                valence: r.valence ?? null, // v9.0: affect-tagged memory
             }));
             if (params.activation?.enabled) {
                 return this.applySynapse(baseResults, params.activation, params.userId);
@@ -1634,7 +1681,7 @@ export class SqliteStorage {
             const anchorMap = new Map();
             for (const a of anchors)
                 anchorMap.set(a.id, a.similarity ?? 1.0);
-            const { results, telemetry } = await propagateActivation(anchorMap, async (nodeIds) => this.getLinksForNodes(nodeIds, userId), {
+            const { results, telemetry, flowWeights } = await propagateActivation(anchorMap, async (nodeIds) => this.getLinksForNodes(nodeIds, userId), {
                 iterations: options.iterations ?? PRISM_SYNAPSE_ITERATIONS,
                 spreadFactor: options.spreadFactor ?? PRISM_SYNAPSE_SPREAD_FACTOR,
                 lateralInhibition: options.lateralInhibition ?? PRISM_SYNAPSE_LATERAL_INHIBITION,
@@ -1649,7 +1696,7 @@ export class SqliteStorage {
             if (missingIds.length > 0) {
                 const placeholders = missingIds.map(() => '?').join(',');
                 const missingQuery = `
-          SELECT id, project, summary, session_date, decisions, files_changed, keywords, is_rollup, importance, last_accessed_at
+          SELECT id, project, summary, session_date, decisions, files_changed, keywords, is_rollup, importance, last_accessed_at, valence
           FROM session_ledger
           WHERE id IN (${placeholders}) AND deleted_at IS NULL AND user_id = ?
         `;
@@ -1666,9 +1713,43 @@ export class SqliteStorage {
                         importance: Number(row.importance) || 0,
                         last_accessed_at: row.last_accessed_at || null,
                         similarity: 0.0,
+                        valence: row.valence ?? null,
                     });
                 }
             }
+            // ── v9.0: Valence Propagation ────────────────────────────────
+            // After activation propagation, compute propagated valence for
+            // discovered nodes using energy-weighted averaging from source flows.
+            let propagatedValenceMap = null;
+            if (PRISM_VALENCE_ENABLED) {
+                try {
+                    const { propagateValence } = await import("../memory/valenceEngine.js");
+                    // Build valence lookup from all known nodes
+                    const valenceLookup = new Map();
+                    for (const [id, node] of fullNodeMap) {
+                        if (node.valence != null)
+                            valenceLookup.set(id, node.valence);
+                    }
+                    // For missing valence values, bulk-fetch from DB
+                    const missingValenceIds = finalIds.filter(id => !valenceLookup.has(id));
+                    if (missingValenceIds.length > 0) {
+                        const vPlaceholders = missingValenceIds.map(() => '?').join(',');
+                        const vQuery = `SELECT id, valence FROM session_ledger WHERE id IN (${vPlaceholders}) AND valence IS NOT NULL`;
+                        const vRes = await this.db.execute({ sql: vQuery, args: missingValenceIds });
+                        for (const row of vRes.rows) {
+                            valenceLookup.set(row.id, row.valence);
+                        }
+                    }
+                    propagatedValenceMap = propagateValence(results, valenceLookup, flowWeights);
+                    debugLog(`[SqliteStorage] v9.0 valence propagation: ${propagatedValenceMap.size} nodes processed`);
+                }
+                catch (valErr) {
+                    debugLog(`[SqliteStorage] v9.0 valence propagation failed (non-fatal): ${valErr instanceof Error ? valErr.message : String(valErr)}`);
+                }
+            }
+            const { computeHybridScoreWithValence } = PRISM_VALENCE_ENABLED
+                ? await import("../memory/valenceEngine.js")
+                : { computeHybridScoreWithValence: null };
             const finalResults = [];
             for (const r of results) {
                 if (fullNodeMap.has(r.id)) {
@@ -1677,8 +1758,19 @@ export class SqliteStorage {
                     node.activationScore = normEnergy;
                     node.rawActivationEnergy = r.activationEnergy;
                     node.isDiscovered = r.isDiscovered;
-                    // Hybrid blend: 70% original match relevance, 30% structural energy
-                    node.hybridScore = (node.similarity * 0.7) + (normEnergy * 0.3);
+                    // v9.0: Attach propagated valence (overrides raw for discovered nodes)
+                    if (propagatedValenceMap?.has(r.id)) {
+                        node.valence = propagatedValenceMap.get(r.id);
+                    }
+                    // v9.0: Hybrid blend with valence salience:
+                    //   0.65 × similarity + 0.25 × activation + 0.10 × |valence|
+                    // Falls back to 70/30 if valence is disabled.
+                    if (computeHybridScoreWithValence) {
+                        node.hybridScore = computeHybridScoreWithValence(node.similarity, normEnergy, node.valence ?? null);
+                    }
+                    else {
+                        node.hybridScore = (node.similarity * 0.7) + (normEnergy * 0.3);
+                    }
                     finalResults.push(node);
                 }
             }
@@ -2847,7 +2939,7 @@ export class SqliteStorage {
         WITH input_kw(kw) AS (VALUES ${placeholders})
         SELECT sl.id, COUNT(DISTINCT ik.kw) AS shared_count
         FROM session_ledger sl,
-             json_each(sl.keywords) AS je,
+             json_each(COALESCE(sl.keywords, '[]')) AS je,
              input_kw ik
         WHERE sl.user_id = ?
           AND sl.project = ?

package/dist/storage/supabase.js

@@ -15,7 +15,7 @@
 import { supabasePost, supabaseGet, supabaseRpc, supabasePatch, supabaseDelete, } from "../utils/supabaseApi.js";
 import { gzipSync, gunzipSync } from "node:zlib";
 import { debugLog } from "../utils/logger.js";
-import { PRISM_USER_ID, PRISM_SYNAPSE_ENABLED, PRISM_SYNAPSE_ITERATIONS, PRISM_SYNAPSE_SPREAD_FACTOR, PRISM_SYNAPSE_LATERAL_INHIBITION, PRISM_SYNAPSE_SOFT_CAP, } from "../config.js";
+import { PRISM_USER_ID, PRISM_SYNAPSE_ENABLED, PRISM_SYNAPSE_ITERATIONS, PRISM_SYNAPSE_SPREAD_FACTOR, PRISM_SYNAPSE_LATERAL_INHIBITION, PRISM_SYNAPSE_SOFT_CAP, PRISM_VALENCE_ENABLED, } from "../config.js";
 import { getSetting as cfgGet, setSetting as cfgSet, getAllSettings as cfgGetAll } from "./configStorage.js";
 import { runAutoMigrations } from "./supabaseMigrations.js";
 import { SafetyController } from "../darkfactory/safetyController.js";
@@ -60,12 +60,48 @@ export class SupabaseStorage {
             ...(entry.embedding_compressed !== undefined && { embedding_compressed: entry.embedding_compressed }),
             ...(entry.embedding_format !== undefined && { embedding_format: entry.embedding_format }),
             ...(entry.embedding_turbo_radius !== undefined && { embedding_turbo_radius: entry.embedding_turbo_radius }),
+            // v9.0: Affect-Tagged Memory
+            ...(entry.valence !== undefined && entry.valence !== null && { valence: entry.valence }),
         };
         return supabasePost("session_ledger", record);
     }
     async patchLedger(id, data) {
         await supabasePatch("session_ledger", data, { id: `eq.${id}` });
     }
+    // v9.0: Atomic delta-based budget persistence
+    // Supabase REST PATCH can't do arithmetic, so we use an RPC function.
+    // Falls back to read-modify-write if the RPC doesn't exist.
+    async patchHandoffBudgetDelta(project, userId, budgetDelta) {
+        try {
+            // Preferred: atomic delta via SQL RPC
+            await supabaseRpc("patch_budget_delta", {
+                p_project: project,
+                p_user_id: userId,
+                p_delta: budgetDelta,
+            });
+        }
+        catch (rpcErr) {
+            // Fallback: read-modify-write (non-atomic, acceptable for Supabase)
+            debugLog(`[SupabaseStorage] patch_budget_delta RPC unavailable, using fallback: ${rpcErr instanceof Error ? rpcErr.message : String(rpcErr)}`);
+            try {
+                const data = await supabaseGet("session_handoffs", {
+                    project: `eq.${project}`,
+                    user_id: `eq.${userId}`,
+                    select: "cognitive_budget",
+                    limit: "1",
+                });
+                const rows = Array.isArray(data) ? data : [];
+                const currentBudget = rows.length > 0 ? rows[0].cognitive_budget ?? 2000 : 2000;
+                await supabasePatch("session_handoffs", { cognitive_budget: Math.max(0, currentBudget + budgetDelta) }, {
+                    project: `eq.${project}`,
+                    user_id: `eq.${userId}`,
+                });
+            }
+            catch (fallbackErr) {
+                debugLog(`[SupabaseStorage] Budget delta fallback also failed: ${fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr)}`);
+            }
+        }
+    }
     async getLedgerEntries(params) {
         const { ids, ...restParams } = params;
         // Construct PostgREST 'in.' payload for array of ids if present
@@ -354,7 +390,7 @@ export class SupabaseStorage {
             const anchorMap = new Map();
             for (const a of anchors)
                 anchorMap.set(a.id, a.similarity ?? 1.0);
-            const { results, telemetry } = await propagateActivation(anchorMap, async (nodeIds) => this.getLinksForNodes(nodeIds, userId), {
+            const { results, telemetry, flowWeights } = await propagateActivation(anchorMap, async (nodeIds) => this.getLinksForNodes(nodeIds, userId), {
                 iterations: options.iterations ?? PRISM_SYNAPSE_ITERATIONS,
                 spreadFactor: options.spreadFactor ?? PRISM_SYNAPSE_SPREAD_FACTOR,
                 lateralInhibition: options.lateralInhibition ?? PRISM_SYNAPSE_LATERAL_INHIBITION,
@@ -374,7 +410,7 @@ export class SupabaseStorage {
                         id: `in.(${missingIds.join(",")})`,
                         user_id: `eq.${userId}`,
                         deleted_at: "is.null",
-                        select: "id,project,summary,session_date,decisions,files_changed,is_rollup,importance,last_accessed_at",
+                        select: "id,project,summary,session_date,decisions,files_changed,is_rollup,importance,last_accessed_at,valence",
                     });
                     for (const row of (Array.isArray(rows) ? rows : [])) {
                         fullNodeMap.set(row.id, {
@@ -387,6 +423,7 @@ export class SupabaseStorage {
                             is_rollup: Boolean(row.is_rollup),
                             importance: Number(row.importance) || 0,
                             last_accessed_at: row.last_accessed_at || null,
+                            valence: row.valence != null ? Number(row.valence) : undefined,
                             similarity: 0.0,
                         });
                     }
@@ -395,6 +432,31 @@ export class SupabaseStorage {
                     debugLog(`[SupabaseStorage] applySynapse: failed to fetch missing nodes: ${e instanceof Error ? e.message : String(e)}`);
                 }
             }
+            // ─── v9.0: Valence Propagation for discovered nodes ──────────
+            // Mirrors the SQLite implementation: batch propagateValence() call
+            // over the full results array with a valence lookup map.
+            let propagatedValenceMap = null;
+            if (PRISM_VALENCE_ENABLED) {
+                try {
+                    const { propagateValence } = await import("../memory/valenceEngine.js");
+                    // Build valence lookup from all known nodes
+                    const valenceLookup = new Map();
+                    for (const [id, node] of fullNodeMap) {
+                        if (node.valence != null && Number.isFinite(node.valence)) {
+                            valenceLookup.set(id, node.valence);
+                        }
+                    }
+                    propagatedValenceMap = propagateValence(results, valenceLookup, flowWeights);
+                    debugLog(`[SupabaseStorage] v9.0 valence propagation: ${propagatedValenceMap.size} nodes processed`);
+                }
+                catch (valErr) {
+                    debugLog(`[SupabaseStorage] applySynapse: valence propagation failed (non-fatal): ${valErr instanceof Error ? valErr.message : String(valErr)}`);
+                }
+            }
+            // Import hybrid scoring if valence is enabled
+            const { computeHybridScoreWithValence } = PRISM_VALENCE_ENABLED
+                ? await import("../memory/valenceEngine.js")
+                : { computeHybridScoreWithValence: null };
             // Compute hybrid scores and build final result set
             const finalResults = [];
             for (const r of results) {
@@ -404,8 +466,15 @@ export class SupabaseStorage {
                     node.activationScore = normEnergy;
                     node.rawActivationEnergy = r.activationEnergy;
                     node.isDiscovered = r.isDiscovered;
-                    // Hybrid blend: 70% original match relevance, 30% structural energy
-                    node.hybridScore = (node.similarity * 0.7) + (normEnergy * 0.3);
+                    // v9.0: Three-component hybrid blend with valence salience
+                    const nodeValence = propagatedValenceMap?.get(r.id) ?? node.valence;
+                    if (computeHybridScoreWithValence && nodeValence != null && Number.isFinite(nodeValence)) {
+                        node.valence = nodeValence;
+                        node.hybridScore = computeHybridScoreWithValence(node.similarity, normEnergy, nodeValence);
+                    }
+                    else {
+                        node.hybridScore = (node.similarity * 0.7) + (normEnergy * 0.3);
+                    }
                     finalResults.push(node);
                 }
             }

package/dist/storage/supabaseMigrations.js

@@ -773,6 +773,36 @@ export const MIGRATIONS = [
         CHECK (status IN ('PENDING', 'RUNNING', 'PAUSED', 'ABORTED', 'COMPLETED', 'FAILED'));
     `
     },
+    {
+        // ─── v9.0: Affect-Tagged Memory + Token-Economic Budget ──────────
+        //
+        // Two new columns:
+        //   1. session_ledger.valence — REAL [-1.0, +1.0], nullable
+        //      Stores the affective "gut feeling" score for each memory entry.
+        //      Derived deterministically from event_type at write time.
+        //      Legacy entries remain NULL (neutral).
+        //
+        //   2. session_handoffs.cognitive_budget — REAL, nullable
+        //      Persists the agent's current token-economic budget balance
+        //      across sessions. Initialized on first spend; NULL before first use.
+        //
+        // Both are idempotent (ADD COLUMN IF NOT EXISTS) and non-breaking
+        // (nullable with no NOT NULL constraint). Existing data is untouched.
+        version: 42,
+        name: "v9_affect_tagged_memory_and_cognitive_budget",
+        sql: `
+      -- v9.0: Affect-Tagged Memory — valence column on session_ledger
+      ALTER TABLE session_ledger ADD COLUMN IF NOT EXISTS valence REAL DEFAULT NULL;
+
+      -- Partial index for valence-aware retrieval (non-null valence entries)
+      CREATE INDEX IF NOT EXISTS idx_ledger_valence
+        ON session_ledger(valence)
+        WHERE valence IS NOT NULL;
+
+      -- v9.0: Token-Economic Cognitive Budget — budget column on session_handoffs
+      ALTER TABLE session_handoffs ADD COLUMN IF NOT EXISTS cognitive_budget REAL DEFAULT NULL;
+    `,
+    },
 ];
 /**
  * Current schema version — derived from the MIGRATIONS array.

package/dist/sync/factory.js

@@ -8,11 +8,15 @@
  */
 import { PRISM_STORAGE } from "../config.js";
 import { debugLog } from "../utils/logger.js";
+import { getSetting } from "../storage/configStorage.js";
 let _bus = null;
 export async function getSyncBus() {
     if (_bus)
         return _bus;
-    if (PRISM_STORAGE === "local") {
+    // DB-first, then env, then config.ts default (same priority as storage/index.ts)
+    const dbStorage = await getSetting("PRISM_STORAGE", "");
+    const resolvedStorage = dbStorage || process.env.PRISM_STORAGE || PRISM_STORAGE;
+    if (resolvedStorage === "local") {
         const { SqliteSyncBus } = await import("./sqliteSync.js");
         _bus = new SqliteSyncBus();
     }

package/dist/tools/graphHandlers.js

@@ -57,6 +57,9 @@ import { HdcStateMachine } from "../sdm/stateMachine.js";
 import { ConceptDictionary } from "../sdm/conceptDictionary.js";
 import { PolicyGateway } from "../sdm/policyGateway.js";
 import { getSdmEngine } from "../sdm/sdmEngine.js";
+// v9.0: Affect-Tagged Memory — valence-aware retrieval
+import { formatValenceTag, generateValenceWarning, } from "../memory/valenceEngine.js";
+import { PRISM_VALENCE_ENABLED } from "../config.js";
 import { PRISM_HDC_ENABLED, PRISM_HDC_EXPLAINABILITY_ENABLED, PRISM_HDC_POLICY_FALLBACK_THRESHOLD, PRISM_HDC_POLICY_CLARIFY_THRESHOLD, } from "../config.js";
 export async function knowledgeSearchHandler(args) {
     if (!isKnowledgeSearchArgs(args)) {
@@ -457,7 +460,11 @@ export async function sessionSearchMemoryHandler(args) {
                 : "";
             // v8.0: Tag nodes discovered via Synapse multi-hop traversal
             const synapseTag = r.isDiscovered ? " [🌐 Synapse]" : "";
-            return `[${i + 1}] ${simScore} similar${synapseTag} — ${r.session_date || "unknown date"}\n` +
+            // v9.0: Valence tag — affect-tagged memory indicator
+            const valTag = PRISM_VALENCE_ENABLED && r.valence != null
+                ? ` ${formatValenceTag(r.valence)}`
+                : "";
+            return `[${i + 1}] ${simScore} similar${synapseTag}${valTag} — ${r.session_date || "unknown date"}\n` +
                 `  Project: ${r.project}\n` +
                 `  Summary: ${r.summary}\n` +
                 importanceStr +
@@ -465,10 +472,25 @@ export async function sessionSearchMemoryHandler(args) {
                 (r.decisions?.length ? `  Decisions: ${r.decisions.join("; ")}\n` : "") +
                 (r.files_changed?.length ? `  Files: ${r.files_changed.join(", ")}\n` : "");
         }).join("\n");
+        // v9.0: Valence Warning — inject contextual warning when top results
+        // have historically negative affect (failures, corrections).
+        let valenceWarning = "";
+        if (PRISM_VALENCE_ENABLED && results.length > 0) {
+            const valenceValues = results
+                .map((r) => r.valence)
+                .filter((v) => v != null && Number.isFinite(v));
+            if (valenceValues.length > 0) {
+                const avgValence = valenceValues.reduce((a, b) => a + b, 0) / valenceValues.length;
+                const warning = generateValenceWarning(avgValence);
+                if (warning) {
+                    valenceWarning = `\n\n${warning}`;
+                }
+            }
+        }
         // Phase 1: content[0] = human-readable results (unchanged from pre-Phase 1)
         const contentBlocks = [{
                 type: "text",
-                text: `🧠 Found ${results.length} semantically similar sessions:\n\n${formatted}`,
+                text: `🧠 Found ${results.length} semantically similar sessions:\n\n${formatted}${valenceWarning}`,
             }];
         // Phase 1: content[1] = machine-readable MemoryTrace (only when enable_trace=true)
         // topScore is read from results[0].similarity — this is the cosine distance

package/dist/tools/ledgerHandlers.js

@@ -29,9 +29,13 @@ import { getLLMProvider } from "../utils/llm/factory.js";
 import { getCurrentGitState, getGitDrift } from "../utils/git.js";
 import { getSetting, getAllSettings } from "../storage/configStorage.js";
 import { mergeHandoff, dbToHandoffSchema, sanitizeForMerge } from "../utils/crdtMerge.js";
-import { GOOGLE_API_KEY, PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS } from "../config.js";
+import { GOOGLE_API_KEY, PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS, PRISM_VALENCE_ENABLED, PRISM_VALENCE_WARNING_THRESHOLD, PRISM_COGNITIVE_BUDGET_ENABLED, } from "../config.js";
 import { captureLocalEnvironment } from "../utils/autoCapture.js";
 import { fireCaptionAsync } from "../utils/imageCaptioner.js";
+// ─── v9.0: Affect-Tagged Memory + Token-Economic RL ──────────
+import { deriveValence } from "../memory/valenceEngine.js";
+import { estimateTokens, spendBudget, applyEarnings, formatBudgetDiagnostics, DEFAULT_BUDGET_SIZE, } from "../memory/cognitiveBudget.js";
+import { computeVectorSurprisal } from "../memory/surprisalGate.js";
 import { isSessionSaveLedgerArgs, isSessionSaveHandoffArgs, isSessionLoadContextArgs, isMemoryHistoryArgs, isMemoryCheckoutArgs, // v2.2.0: health check type guard
 isSessionForgetMemoryArgs, // v3.1: TTL retention policy type guard
 // v4.0: Active Behavioral Memory type guards
@@ -83,6 +87,73 @@ export async function sessionSaveLedgerHandler(args) {
     const combinedText = [summary, ...(decisions || [])].join(" ");
     const keywords = toKeywordArray(combinedText);
     debugLog(`[session_save_ledger] Extracted ${keywords.length} keywords: ${keywords.slice(0, 5).join(", ")}...`);
+    // ── v9.0: Auto-derive valence from event_type ──────────────────
+    // Valence is a [-1, +1] real representing the affective charge of a memory.
+    // It's auto-derived at create-time from the event_type field so the agent
+    // doesn't need to manually classify emotional context.
+    let valence = null;
+    let valenceWarning = "";
+    if (PRISM_VALENCE_ENABLED) {
+        const eventType = args.event_type || "session";
+        valence = deriveValence(eventType);
+        if (valence !== null && valence < PRISM_VALENCE_WARNING_THRESHOLD) {
+            valenceWarning = `\n\n⚠️ **Negative Valence (${valence.toFixed(2)}):** This entry is tagged as a negative experience. ` +
+                `It will be prioritized in future retrievals to prevent repeating past mistakes.`;
+        }
+        debugLog(`[session_save_ledger] v9.0 valence derived: ${valence} (event_type=${eventType})`);
+    }
+    // ── v9.0: Token-Economic Budget ────────────────────────────────
+    // Charge the project's cognitive budget for this write operation.
+    // Budget exhaustion triggers warnings but NEVER blocks writes (graceful degradation).
+    let budgetDiagnostics = "";
+    let queryEmbedding = null;
+    if (PRISM_COGNITIVE_BUDGET_ENABLED) {
+        try {
+            // Load current budget from the project's handoff state
+            const handoff = await storage.loadContext(project, "quick", PRISM_USER_ID);
+            const currentBudget = handoff?.cognitive_budget ?? DEFAULT_BUDGET_SIZE;
+            // Apply UBI earnings before spending.
+            // NOTE: event_type is intentionally NOT passed to applyEarnings().
+            // The "infinite money glitch" — LLMs self-declare event_type: "success"
+            // to mint free tokens. Budget bonuses should only come from the
+            // Dark Factory adversarial evaluator. Valence derivation still uses
+            // event_type correctly for affect tagging.
+            const lastCreated = handoff?.updated_at ?? null;
+            const earnings = applyEarnings(currentBudget, lastCreated, undefined);
+            // v9.0: Compute real surprisal via vector similarity search.
+            // Uses the existing embedding pipeline — generates the embedding
+            // early so we can reuse it for the post-save embedding patch.
+            let surprisal = 0.5; // Fallback: neutral surprisal
+            if (GOOGLE_API_KEY) {
+                try {
+                    const embeddingText = [summary, ...(decisions || [])].join("\n");
+                    queryEmbedding = await getLLMProvider().generateEmbedding(embeddingText);
+                    const surprisalResult = await computeVectorSurprisal(storage.searchMemory.bind(storage), JSON.stringify(queryEmbedding), project, PRISM_USER_ID);
+                    surprisal = surprisalResult.surprisal;
+                    debugLog(`[session_save_ledger] v9.0 surprisal: ${surprisal.toFixed(3)} (${surprisalResult.isBoilerplate ? 'boilerplate' : surprisalResult.isNovel ? 'novel' : 'standard'})`);
+                }
+                catch (surprErr) {
+                    debugLog(`[session_save_ledger] Surprisal computation failed (using 0.5 fallback): ${surprErr instanceof Error ? surprErr.message : String(surprErr)}`);
+                }
+            }
+            const rawTokenCost = estimateTokens(summary);
+            const result = spendBudget(earnings.newBalance, rawTokenCost, surprisal);
+            // Format diagnostics for MCP response
+            budgetDiagnostics = "\n\n" + formatBudgetDiagnostics(result, DEFAULT_BUDGET_SIZE, earnings.ubiEarned, earnings.bonusEarned);
+            // v9.0: Persist budget using delta-based update to prevent concurrency race.
+            // If Agent A and Agent B both load budget=2000 concurrently, absolute writes
+            // cause Agent A's spend to be overwritten by Agent B's stale value.
+            // Delta update: UPDATE SET cognitive_budget = COALESCE(cognitive_budget, 2000) + delta
+            const budgetDelta = (earnings.ubiEarned + earnings.bonusEarned) - result.spent;
+            storage.patchHandoffBudgetDelta(project, PRISM_USER_ID, budgetDelta).catch((err) => {
+                debugLog(`[session_save_ledger] Budget persist failed (non-fatal): ${err.message}`);
+            });
+            debugLog(`[session_save_ledger] v9.0 budget: cost=${result.spent}, balance=${result.remaining}, delta=${budgetDelta}`);
+        }
+        catch (budgetErr) {
+            debugLog(`[session_save_ledger] Budget tracking failed (non-fatal): ${budgetErr instanceof Error ? budgetErr.message : String(budgetErr)}`);
+        }
+    }
     // Save via storage backend
     const effectiveRole = role || await getSetting("default_role", "global");
     const result = await storage.saveLedger({
@@ -95,14 +166,19 @@ export async function sessionSaveLedgerHandler(args) {
         decisions: decisions || [],
         keywords,
         role: effectiveRole, // v3.0: Hivemind role scoping (dashboard fallback)
+        valence, // v9.0: Affect-tagged memory
     });
     // ─── Fire-and-forget embedding generation ───
     if (GOOGLE_API_KEY && result) {
-        const embeddingText = [summary, ...(decisions || [])].join("\n");
         const savedEntry = Array.isArray(result) ? result[0] : result;
         const entryId = savedEntry?.id;
         if (entryId) {
-            getLLMProvider().generateEmbedding(embeddingText)
+            // If embedding was already generated during surprisal computation, reuse it.
+            // Otherwise, generate it now (fire-and-forget).
+            const embeddingPromise = queryEmbedding
+                ? Promise.resolve(queryEmbedding)
+                : getLLMProvider().generateEmbedding([summary, ...(decisions || [])].join("\n"));
+            embeddingPromise
                 .then(async (embedding) => {
                 // Build atomic patch — float32 + TurboQuant in ONE DB update
                 const patchData = {
@@ -194,7 +270,10 @@ export async function sessionSaveLedgerHandler(args) {
                     (files_changed?.length ? `Files changed: ${files_changed.length}\n` : "") +
                     (decisions?.length ? `Decisions: ${decisions.length}\n` : "") +
                     (GOOGLE_API_KEY ? `📊 Embedding generation queued for semantic search.\n` : "") +
+                    (valence !== null ? `🎭 Valence: ${valence.toFixed(2)}\n` : "") +
                     repoPathWarning +
+                    valenceWarning +
+                    budgetDiagnostics +
                     `\nRaw response: ${JSON.stringify(result)}`,
             }],
         isError: false,
@@ -720,8 +799,38 @@ export async function sessionLoadContextHandler(args) {
             debugLog(`[session_load_context] SDM Recall failed (non-fatal): ${err instanceof Error ? err.message : err}`);
         }
     }
+    // ─── v9.0: Cognitive Budget Diagnostics ──────────────────────
+    // Show the agent its current token-economic budget status at session start.
+    // This gives real-time feedback on spending capacity and health.
+    let budgetDiagBlock = "";
+    if (PRISM_COGNITIVE_BUDGET_ENABLED && level !== "quick") {
+        try {
+            const currentBudget = d.cognitive_budget ?? DEFAULT_BUDGET_SIZE;
+            const budgetSize = DEFAULT_BUDGET_SIZE;
+            const ratio = Math.max(0, Math.min(1, currentBudget / budgetSize));
+            const barLength = 20;
+            const fillLength = Math.round(ratio * barLength);
+            const bar = '█'.repeat(Math.max(0, fillLength)) + '░'.repeat(Math.max(0, barLength - fillLength));
+            let healthLabel;
+            if (ratio > 0.6)
+                healthLabel = "🟢 Healthy";
+            else if (ratio > 0.3)
+                healthLabel = "🟡 Moderate";
+            else if (ratio > 0.1)
+                healthLabel = "🟠 Low";
+            else
+                healthLabel = "🔴 Critical";
+            budgetDiagBlock = `\n\n[💰 COGNITIVE BUDGET]\n` +
+                `${bar} ${currentBudget}/${budgetSize} tokens — ${healthLabel}\n` +
+                `Budget replenishes via UBI (+5 tokens/hour) and event bonuses (success: +20, learning: +10).`;
+            debugLog(`[session_load_context] v9.0 budget diagnostics: ${currentBudget}/${budgetSize} (${(ratio * 100).toFixed(0)}%)`);
+        }
+        catch (budgetErr) {
+            debugLog(`[session_load_context] Budget diagnostics failed (non-fatal): ${budgetErr instanceof Error ? budgetErr.message : String(budgetErr)}`);
+        }
+    }
     // Build the response object before v4.0 augmentations
-    let responseText = `📋 Session context for "${project}" (${level}):\n\n${formattedContext.trim()}${driftReport}${briefingBlock}${sdmRecallBlock}${greetingBlock}${visualMemoryBlock}${skillBlock}${versionNote}`;
+    let responseText = `📋 Session context for "${project}" (${level}):\n\n${formattedContext.trim()}${driftReport}${briefingBlock}${sdmRecallBlock}${greetingBlock}${visualMemoryBlock}${skillBlock}${budgetDiagBlock}${versionNote}`;
     // ─── v4.0: Behavioral Warnings Injection ───────────────────
     // If loadContext returned behavioral_warnings, add them to the
     // formatted output so the agent sees them prominently.
@@ -1090,6 +1199,14 @@ export async function sessionSaveExperienceHandler(args) {
     const keywords = toKeywordArray(summary);
     debugLog(`[session_save_experience] Extracted ${keywords.length} keywords: ${keywords.slice(0, 5).join(", ")}...`);
     const effectiveRole = role || await getSetting("default_role", "global");
+    // v9.0: Experience events are the PRIMARY source of valence.
+    // A failure event without valence = -0.8 is invisible to affective routing.
+    // This was Bug #7 — the feature was wired in sessionSaveLedgerHandler but
+    // missing in the handler that matters most for typed events.
+    const valence = PRISM_VALENCE_ENABLED ? deriveValence(event_type, outcome) : null;
+    if (valence !== null) {
+        debugLog(`[session_save_experience] v9.0 valence derived: ${valence} (event_type=${event_type})`);
+    }
     const result = await storage.saveLedger({
         project,
         conversation_id: "experience-event",
@@ -1107,6 +1224,7 @@ export async function sessionSaveExperienceHandler(args) {
         confidence_score: typeof confidence_score === "number" ? confidence_score : undefined,
         // Corrections start with importance 1 to jumpstart visibility
         importance: event_type === "correction" ? 1 : 0,
+        valence, // v9.0: Affect-tagged memory — derived from event_type
     });
     // Fire-and-forget embedding generation
     if (GOOGLE_API_KEY && result) {