@cleocode/cleo 2026.9.7 → 2026.9.10

package/studio-dist/server/chunks/surprisal-CwTfWQi8.js

@@ -1,224 +0,0 @@
-import { k as getBrainNativeDb } from './sqlite-Bm5LzbPs.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './dual-scope-db-DKnWu1KM.js';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './nexus-sqlite2-BBfY2xnY.js';
-import './nexus-schema2-DP0Qd7CA.js';
-import './chunk-DDP5xfzh.js';
-import './logger-DQIoyZbq.js';
-import 'node:sqlite';
-import './unique-constraint-BZrrwgwc.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-
-//#region ../core/dist/memory/surprisal.js
-/**
-* Bayesian Surprisal Scoring — T1146 Wave 6 Dreamer Upgrade
-*
-* Computes a surprisal score for a brain_observation relative to prior
-* context (existing embeddings in the same project/peer scope).
-*
-* Surprisal definition: how much new information does this observation
-* add to the existing memory state?
-*
-*   score = -log(P(observation | prior_context))
-*
-* Implementation:
-*   - High score (novel, >0.7): observation is semantically distant from all
-*     stored embeddings → high priority for consolidation
-*   - Low score (redundant, <0.3): observation is very similar to an existing
-*     embedding → low priority, may be merged/skipped
-*   - Neutral (0.5): returned when embeddings unavailable (graceful degrade)
-*
-* Temporal decay and confidence weighting from BRAIN_SOURCE_CONFIDENCE are
-* applied to adjust the prior similarity.
-*
-* No external library: pure TypeScript cosine similarity + log transform.
-*
-* @task T1146
-* @epic T1146
-*/
-/** Neutral surprisal returned when embeddings are unavailable. */
-var NEUTRAL_SURPRISAL = .5;
-/** Minimum surprisal score (most redundant). */
-var MIN_SURPRISAL = 0;
-/** Maximum surprisal score (most novel). */
-var MAX_SURPRISAL = 1;
-/**
-* Cosine similarity threshold above which two observations are considered
-* semantically identical (very low surprisal).
-*/
-var HIGH_SIMILARITY_THRESHOLD = .92;
-/**
-* Cosine similarity threshold below which two observations are considered
-* semantically unrelated (high surprisal — novel).
-*/
-var LOW_SIMILARITY_THRESHOLD = .35;
-/** Max number of prior embeddings to compare against for efficiency. */
-var MAX_PRIOR_EMBEDDINGS = 50;
-/** Temporal decay half-life in days. Recent observations have more weight. */
-var DECAY_HALF_LIFE_DAYS = 30;
-/**
-* Compute cosine similarity between two float arrays.
-* Returns 0 if either vector is zero or lengths differ.
-*/
-function cosineSimilarity(a, b) {
-	if (a.length !== b.length || a.length === 0) return 0;
-	let dot = 0;
-	let normA = 0;
-	let normB = 0;
-	for (let i = 0; i < a.length; i++) {
-		dot += (a[i] ?? 0) * (b[i] ?? 0);
-		normA += (a[i] ?? 0) ** 2;
-		normB += (b[i] ?? 0) ** 2;
-	}
-	const denom = Math.sqrt(normA) * Math.sqrt(normB);
-	return denom === 0 ? 0 : dot / denom;
-}
-/**
-* Apply temporal decay to a similarity score.
-* More recent priors have higher weight; old priors decay toward zero.
-*/
-function applyTemporalDecay(similarity, priorCreatedAt) {
-	if (!priorCreatedAt) return similarity;
-	return similarity * .5 ** ((Date.now() - new Date(priorCreatedAt).getTime()) / (1e3 * 60 * 60 * 24) / DECAY_HALF_LIFE_DAYS);
-}
-/**
-* Deserialize a Float32 embedding from a SQLite BLOB Buffer.
-*/
-function bufferToFloat32Array(buf) {
-	const floats = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
-	return Array.from(floats);
-}
-/**
-* Fetch prior embeddings from brain_embeddings table for the given scope.
-*/
-function fetchPriorEmbeddings(nativeDb, excludeObsId, _project, _peerId) {
-	return nativeDb.prepare(`SELECT e.id, e.embedding, o.created_at
-       FROM brain_embeddings e
-       JOIN brain_observations o ON o.id = e.id
-       WHERE e.id != ?
-         AND e.embedding IS NOT NULL
-       ORDER BY o.created_at DESC
-       LIMIT ?`).all(excludeObsId, MAX_PRIOR_EMBEDDINGS).filter((r) => r.embedding !== null && r.embedding.byteLength > 0).map((r) => ({
-		id: r.id,
-		embedding: bufferToFloat32Array(r.embedding),
-		createdAt: r.created_at
-	}));
-}
-/**
-* Compute a Bayesian surprisal score for a single observation.
-*
-* Returns a value in [0.0, 1.0]:
-*   - >0.7 → novel (high surprisal) — high consolidation priority
-*   - <0.3 → redundant (low surprisal) — skip or merge
-*   - 0.5  → neutral (no embeddings available)
-*
-* Degrades gracefully when embeddings are unavailable:
-* returns NEUTRAL_SURPRISAL (0.5) with a console.warn, never throws.
-*
-* @param observation - The observation to score (must include embedding if available).
-* @param options     - Scope, db injection for tests.
-* @returns SurprisalResult with score and diagnostics.
-*
-* @task T1146
-*/
-function computeSurprisalScore(observation, options = {}) {
-	const { db: injectedDb, project = null, peerId = "global" } = options;
-	const nativeDb = injectedDb !== void 0 ? injectedDb : getBrainNativeDb();
-	if (!observation.embedding || observation.embedding.length === 0) {
-		if (!nativeDb) console.warn("[surprisal] No database available; returning neutral score.");
-		return {
-			id: observation.id,
-			score: NEUTRAL_SURPRISAL,
-			embeddingAvailable: false
-		};
-	}
-	if (!nativeDb) {
-		console.warn("[surprisal] Database not initialized; returning neutral score.");
-		return {
-			id: observation.id,
-			score: NEUTRAL_SURPRISAL,
-			embeddingAvailable: false
-		};
-	}
-	try {
-		const priors = fetchPriorEmbeddings(nativeDb, observation.id, project, peerId);
-		if (priors.length === 0) return {
-			id: observation.id,
-			score: MAX_SURPRISAL,
-			embeddingAvailable: true,
-			maxSimilarity: 0
-		};
-		let maxDecayedSimilarity = 0;
-		let mostSimilarId;
-		for (const prior of priors) {
-			const decayedSim = applyTemporalDecay(cosineSimilarity(observation.embedding, prior.embedding), prior.createdAt);
-			if (decayedSim > maxDecayedSimilarity) {
-				maxDecayedSimilarity = decayedSim;
-				mostSimilarId = prior.id;
-			}
-		}
-		let score;
-		if (maxDecayedSimilarity >= HIGH_SIMILARITY_THRESHOLD) score = MIN_SURPRISAL + (1 - maxDecayedSimilarity) * .3;
-		else if (maxDecayedSimilarity <= LOW_SIMILARITY_THRESHOLD) score = .7 + (1 - maxDecayedSimilarity) * .3;
-		else score = .7 - (maxDecayedSimilarity - LOW_SIMILARITY_THRESHOLD) / (HIGH_SIMILARITY_THRESHOLD - LOW_SIMILARITY_THRESHOLD) * .4;
-		score = Math.max(MIN_SURPRISAL, Math.min(MAX_SURPRISAL, score));
-		return {
-			id: observation.id,
-			score,
-			embeddingAvailable: true,
-			mostSimilarId,
-			maxSimilarity: maxDecayedSimilarity
-		};
-	} catch (err) {
-		console.warn("[surprisal] Error computing score; returning neutral:", err);
-		return {
-			id: observation.id,
-			score: NEUTRAL_SURPRISAL,
-			embeddingAvailable: false
-		};
-	}
-}
-/**
-* Compute surprisal scores for a batch of observations, sorted descending.
-*
-* High-surprisal observations are returned first — they should be processed
-* by the dreamer first (bypass normal rate limit).
-*
-* @param observations - Batch to score.
-* @param options      - Scope, db injection.
-* @returns Sorted array with highest surprisal first.
-*
-* @task T1146
-*/
-function computeSurprisalBatch(observations, options = {}) {
-	return observations.map((obs) => computeSurprisalScore(obs, options)).sort((a, b) => b.score - a.score);
-}
-
-export { NEUTRAL_SURPRISAL, computeSurprisalBatch, computeSurprisalScore };
-//# sourceMappingURL=surprisal-CwTfWQi8.js.map

package/studio-dist/server/chunks/surprisal-tree-7dfHsuw1.js

@@ -1,230 +0,0 @@
-import { k as getBrainNativeDb } from './sqlite-Bm5LzbPs.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './dual-scope-db-DKnWu1KM.js';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './nexus-sqlite2-BBfY2xnY.js';
-import './nexus-schema2-DP0Qd7CA.js';
-import './chunk-DDP5xfzh.js';
-import './logger-DQIoyZbq.js';
-import 'node:sqlite';
-import './unique-constraint-BZrrwgwc.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-
-//#region ../core/dist/memory/surprisal-tree.js
-/**
-* RPTree — Random Projection Tree for hierarchical memory clustering
-*
-* Implements a simplified Random Projection Tree (RPTree) that partitions
-* a set of observation embeddings into a hierarchical cluster structure.
-* Each leaf node contains a group of semantically-similar observations.
-*
-* Algorithm:
-*   1. Generate a random projection vector
-*   2. Compute dot products of all embeddings with the projection
-*   3. Split at the median (left = below, right = above)
-*   4. Recurse until min_leaf_size or max_depth is reached
-*
-* Trees are rebuilt each dream cycle (brain_memory_trees table is truncated
-* and repopulated). This is intentional — trees are a cache, not a source
-* of truth.
-*
-* Persistence: tree nodes are written to brain_memory_trees. The leaf node
-* id is written back to brain_observations.tree_id.
-*
-* @task T1146
-* @epic T1146
-*/
-/** Maximum tree depth. Prevents infinite recursion on tiny datasets. */
-var MAX_DEPTH = 8;
-/** Minimum leaf size: stop splitting when a node has this many obs or fewer. */
-var MIN_LEAF_SIZE = 3;
-/** Embedding dimension. Matches CLEO brain embeddings (OpenAI/Anthropic = 1536 or 768). */
-var DEFAULT_EMBEDDING_DIM = 1536;
-/**
-* Generate a random unit vector of dimension `dim` using Box-Muller transform.
-*
-* Uses Math.random() (uniform [0,1)) rather than raw randomBytes Float32 bit
-* patterns — the previous implementation interpreted crypto byte sequences as
-* Float32 values, which can produce NaN/Infinity components that propagate
-* through dot products and corrupt the median split (T-spec-flake fix).
-*/
-function randomProjectionVector(dim) {
-	const result = [];
-	let norm = 0;
-	for (let i = 0; i < dim; i += 2) {
-		const u1 = Math.random() || 1e-300;
-		const u2 = Math.random();
-		const r = Math.sqrt(-2 * Math.log(u1));
-		const theta = 2 * Math.PI * u2;
-		const z0 = r * Math.cos(theta);
-		const z1 = r * Math.sin(theta);
-		result.push(z0);
-		norm += z0 * z0;
-		if (i + 1 < dim) {
-			result.push(z1);
-			norm += z1 * z1;
-		}
-	}
-	const normSqrt = Math.sqrt(norm) || 1;
-	return result.map((v) => v / normSqrt);
-}
-/** Dot product of two equal-length arrays. */
-function dotProduct(a, b) {
-	let sum = 0;
-	const len = Math.min(a.length, b.length);
-	for (let i = 0; i < len; i++) sum += (a[i] ?? 0) * (b[i] ?? 0);
-	return sum;
-}
-/** Compute centroid (mean) of a set of embeddings. */
-function computeCentroid(embeddings) {
-	if (embeddings.length === 0) return null;
-	const dim = embeddings[0]?.length ?? 0;
-	const centroid = new Array(dim).fill(0);
-	for (const emb of embeddings) for (let i = 0; i < dim; i++) centroid[i] = (centroid[i] ?? 0) + (emb[i] ?? 0);
-	return centroid.map((v) => v / embeddings.length);
-}
-/**
-* Recursively build an RPTree node for the given subset of observations.
-*/
-function buildNode(observations, depth, parentDbId, maxDepth, minLeafSize) {
-	const embeddings = observations.map((o) => o.embedding);
-	const centroid = computeCentroid(embeddings);
-	if (observations.length <= minLeafSize || depth >= maxDepth) return {
-		depth,
-		leafIds: observations.map((o) => o.id),
-		centroid,
-		parentDbId,
-		children: []
-	};
-	const projVector = randomProjectionVector(embeddings[0]?.length ?? DEFAULT_EMBEDDING_DIM);
-	const projected = observations.map((obs) => ({
-		obs,
-		proj: dotProduct(obs.embedding, projVector)
-	}));
-	const projValues = projected.map((p) => p.proj).sort((a, b) => a - b);
-	const median = projValues[Math.floor(projValues.length / 2)] ?? 0;
-	const left = projected.filter((p) => p.proj <= median).map((p) => p.obs);
-	const right = projected.filter((p) => p.proj > median).map((p) => p.obs);
-	if (left.length === 0 || right.length === 0) return {
-		depth,
-		leafIds: observations.map((o) => o.id),
-		centroid,
-		parentDbId,
-		children: []
-	};
-	return {
-		depth,
-		leafIds: [],
-		centroid,
-		parentDbId,
-		children: [buildNode(left, depth + 1, null, maxDepth, minLeafSize), buildNode(right, depth + 1, null, maxDepth, minLeafSize)]
-	};
-}
-/**
-* Persist a tree node to the database and return its assigned id.
-* Recursively persists children, updating their parentDbId.
-*/
-function persistNode(node, nativeDb, parentDbId) {
-	const centroidJson = node.centroid ? JSON.stringify(node.centroid) : null;
-	const leafIdsJson = JSON.stringify(node.leafIds);
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const result = nativeDb.prepare(`INSERT INTO brain_memory_trees (depth, leaf_ids, centroid, parent_id, created_at)
-       VALUES (?, ?, ?, ?, ?)`).run(node.depth, leafIdsJson, centroidJson, parentDbId, now);
-	const nodeId = Number(result.lastInsertRowid);
-	for (const child of node.children) persistNode(child, nativeDb, nodeId);
-	return nodeId;
-}
-/**
-* Collect all leaf nodes and their observation IDs for brain_observations update.
-*/
-function collectLeafAssignments(node, nodeId, nativeDb, assignments) {
-	if (node.leafIds.length > 0) for (const obsId of node.leafIds) assignments.set(obsId, nodeId);
-	if (node.children.length > 0) {
-		const children = nativeDb.prepare(`SELECT id, leaf_ids FROM brain_memory_trees WHERE parent_id = ?`).all(nodeId);
-		for (const childRow of children) {
-			const childLeafIds = JSON.parse(childRow.leaf_ids);
-			if (childLeafIds.length > 0) for (const obsId of childLeafIds) assignments.set(obsId, childRow.id);
-		}
-	}
-}
-/**
-* Build a Random Projection Tree from a set of observations and persist it
-* to brain_memory_trees. Updates brain_observations.tree_id for all leaf members.
-*
-* Truncates existing brain_memory_trees rows before writing (trees are
-* rebuilt each dream cycle from scratch).
-*
-* Requires at least 2 observations. Returns early with zero counts if fewer
-* are provided.
-*
-* @param observations - Set of observations with embeddings to cluster.
-* @param options      - Depth/leaf config, db injection for tests.
-* @returns Build result with node/assignment counts.
-*
-* @task T1146
-*/
-function buildSurprisalTree(observations, options = {}) {
-	const { maxDepth = MAX_DEPTH, minLeafSize = MIN_LEAF_SIZE, db: injectedDb } = options;
-	const result = {
-		nodesWritten: 0,
-		obsAssigned: 0,
-		actualMaxDepth: 0
-	};
-	const eligible = observations.filter((o) => o.embedding.length > 0);
-	if (eligible.length < 2) return result;
-	const nativeDb = injectedDb !== void 0 ? injectedDb : getBrainNativeDb();
-	if (!nativeDb) {
-		console.warn("[surprisal-tree] No database available; skipping tree build.");
-		return result;
-	}
-	try {
-		nativeDb.exec("DELETE FROM brain_memory_trees");
-		const rootNode = buildNode(eligible, 0, null, maxDepth, minLeafSize);
-		const rootId = persistNode(rootNode, nativeDb, null);
-		result.nodesWritten = nativeDb.prepare("SELECT COUNT(*) AS cnt FROM brain_memory_trees").get()?.cnt ?? 0;
-		result.actualMaxDepth = nativeDb.prepare("SELECT MAX(depth) AS maxd FROM brain_memory_trees").get()?.maxd ?? 0;
-		const assignments = /* @__PURE__ */ new Map();
-		collectLeafAssignments(rootNode, rootId, nativeDb, assignments);
-		const leafRows = nativeDb.prepare(`SELECT id, leaf_ids FROM brain_memory_trees WHERE leaf_ids != '[]'`).all();
-		for (const leafRow of leafRows) {
-			const leafIds = JSON.parse(leafRow.leaf_ids);
-			for (const obsId of leafIds) assignments.set(obsId, leafRow.id);
-		}
-		for (const [obsId, treeNodeId] of assignments) {
-			nativeDb.prepare("UPDATE brain_observations SET tree_id = ? WHERE id = ?").run(treeNodeId, obsId);
-			result.obsAssigned++;
-		}
-		return result;
-	} catch (err) {
-		console.warn("[surprisal-tree] Error building tree:", err);
-		return result;
-	}
-}
-
-export { buildSurprisalTree };
-//# sourceMappingURL=surprisal-tree-7dfHsuw1.js.map

package/studio-dist/server/chunks/system-resolver2-Bzhue_zQ.js

@@ -1,53 +0,0 @@
-import { r as resolveLLMForSystem } from './local-model-fit2-BMqo6GJm.js';
-import './chunk-DDP5xfzh.js';
-import 'node:module';
-import 'node:fs';
-import 'node:path';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:os';
-import './paths-CV7S5-Zm.js';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:process';
-import 'node:async_hooks';
-import './src2-DK8DKufK.js';
-import './branch-lock-Cq7zzmFK.js';
-import './sqlite-Bm5LzbPs.js';
-import './dual-scope-db-DKnWu1KM.js';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './nexus-sqlite2-BBfY2xnY.js';
-import './nexus-schema2-DP0Qd7CA.js';
-import './logger-DQIoyZbq.js';
-import 'node:sqlite';
-import './unique-constraint-BZrrwgwc.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-import 'node:fs/promises';
-import 'node:util';
-import './config-DHj9CcFs.js';
-import './json-Bfixam3g.js';
-import './index-61916rmV.js';
-import './credential-pool-vF6NdtT9.js';
-import './catalog-model-resolver2-Cexk2TN0.js';
-import './role-resolver-D9QaDT0e.js';
-import './identity2-DeAB5RXE.js';
-
-
-
-export { resolveLLMForSystem };
-//# sourceMappingURL=system-resolver2-Bzhue_zQ.js.map