@cleocode/cleo 2026.9.7 → 2026.9.9

package/studio-dist/server/chunks/edge-types-CgBvb0w1.js

@@ -1,28 +0,0 @@
-//#region ../core/dist/memory/edge-types.js
-/**
-* Canonical edge-type constants for `brain_page_edges`.
-*
-* All code that writes or queries `brain_page_edges.edge_type` MUST use
-* these constants instead of raw string literals to prevent enum drift.
-*
-* The values here are a subset of `BRAIN_EDGE_TYPES` (memory-schema.ts).
-* They are duplicated as constants so callers do not need to import the
-* schema module (which carries Drizzle + SQLite dependencies).
-*
-* @epic T626
-*/
-var EDGE_TYPES = {
-	CO_RETRIEVED: "co_retrieved",
-	SUPERSEDES: "supersedes",
-	APPLIES_TO: "applies_to",
-	DERIVED_FROM: "derived_from",
-	AFFECTS: "affects",
-	MENTIONS: "mentions",
-	DOCUMENTS: "documents",
-	CODE_REFERENCE: "code_reference",
-	CONDUIT_MENTIONS_SYMBOL: "conduit_mentions_symbol",
-	TASK_TOUCHES_SYMBOL: "task_touches_symbol"
-};
-
-export { EDGE_TYPES as E };
-//# sourceMappingURL=edge-types-CgBvb0w1.js.map

package/studio-dist/server/chunks/embedding-local-xEnym8Ho.js

@@ -1,92 +0,0 @@
-//#region ../core/dist/memory/embedding-local.js
-/**
-* Local embedding provider using @huggingface/transformers (transformers.js v4).
-*
-* Implements the EmbeddingProvider interface for brain memory vector search.
-* Uses all-MiniLM-L6-v2 (22MB, 384 dimensions) — matches the brain_embeddings
-* vec0 table schema. Model downloads on first call and is cached locally by
-* the transformers library.
-*
-* @epic T134
-* @task T136
-* @why Ship vector search out-of-the-box without external API keys
-* @what Local embedding provider using @huggingface/transformers all-MiniLM-L6-v2
-* @remarks Brain embeddings are a FIRST-CLASS CLEO feature — the transformers
-*   package is a regular dependency of `@cleocode/core`, not optional.
-*   Migrated from `@xenova/transformers` v2 to `@huggingface/transformers`
-*   v4 (upstream rename, same author) which drops the deprecated
-*   `prebuild-install` transitive via `sharp@0.34+`.
-*/
-/** Model identifier for all-MiniLM-L6-v2 via Xenova hub. */
-var MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
-/** Pipeline singleton — initialized lazily on first call. */
-var _pipeline = null;
-/** Whether the pipeline has been successfully initialized. */
-var _ready = false;
-/**
-* Load the transformers feature-extraction pipeline lazily.
-* Dynamic import prevents the heavy model from loading unless embedding is enabled.
-*/
-async function loadPipeline() {
-	if (_ready) return;
-	const { pipeline } = await import('./transformers.node-_xbxmK5p.js');
-	_pipeline = await pipeline("feature-extraction", MODEL_NAME);
-	_ready = true;
-}
-/**
-* Local embedding provider backed by @huggingface/transformers.
-*
-* Produces 384-dimension Float32Array vectors compatible with the
-* brain_embeddings vec0 table. The model is downloaded on first use
-* and cached locally by the transformers library.
-*
-* Use {@link initDefaultProvider} (in brain-embedding.ts) to register an
-* instance when brain.embedding.enabled=true and
-* brain.embedding.provider='local'.
-*/
-var LocalEmbeddingProvider = class {
-	/** Number of dimensions produced — must match brain_embeddings vec0 table. */
-	dimensions = 384;
-	/**
-	* Whether the pipeline has been successfully initialized and is ready to produce embeddings.
-	*/
-	isAvailable() {
-		return _ready;
-	}
-	/**
-	* Convert a single text string into a 384-dimension float vector.
-	* Triggers model download on first call if not already cached.
-	*
-	* @param text - The text to embed.
-	* @returns A Float32Array of length 384.
-	*/
-	async embed(text) {
-		await loadPipeline();
-		const output = await _pipeline(text, {
-			pooling: "mean",
-			normalize: true
-		});
-		return Float32Array.from(output.data);
-	}
-	/**
-	* Embed multiple texts in sequence, reusing the cached pipeline.
-	*
-	* @param texts - Array of text strings to embed.
-	* @returns Array of Float32Array vectors, one per input text.
-	*/
-	async embedBatch(texts) {
-		await loadPipeline();
-		const results = [];
-		for (const text of texts) {
-			const output = await _pipeline(text, {
-				pooling: "mean",
-				normalize: true
-			});
-			results.push(Float32Array.from(output.data));
-		}
-		return results;
-	}
-};
-
-export { LocalEmbeddingProvider };
-//# sourceMappingURL=embedding-local-xEnym8Ho.js.map

package/studio-dist/server/chunks/event-streams-Bi2p_fVo.js

@@ -1,232 +0,0 @@
-import { t as toUtf8$1, m as fromUtf8$1 } from './role-executor-CC8BU54L.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 './credential-pool-vF6NdtT9.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-import './config-DHj9CcFs.js';
-import './json-Bfixam3g.js';
-import './lock-CA7d6lj7.js';
-import 'node:fs/promises';
-import './index-61916rmV.js';
-import './role-resolver-D9QaDT0e.js';
-import 'node:stream';
-import 'crypto';
-import 'os';
-import 'node:http2';
-import 'fs/promises';
-import 'node:net';
-
-//#region ../../node_modules/.pnpm/@smithy+core@3.24.3/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
-var EventStreamSerde = class {
-	marshaller;
-	serializer;
-	deserializer;
-	serdeContext;
-	defaultContentType;
-	constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType }) {
-		this.marshaller = marshaller;
-		this.serializer = serializer;
-		this.deserializer = deserializer;
-		this.serdeContext = serdeContext;
-		this.defaultContentType = defaultContentType;
-	}
-	async serializeEventStream({ eventStream, requestSchema, initialRequest }) {
-		const marshaller = this.marshaller;
-		const eventStreamMember = requestSchema.getEventStreamMember();
-		const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
-		const serializer = this.serializer;
-		const defaultContentType = this.defaultContentType;
-		const initialRequestMarker = Symbol("initialRequestMarker");
-		const eventStreamIterable = { async *[Symbol.asyncIterator]() {
-			if (initialRequest) {
-				const headers = {
-					":event-type": {
-						type: "string",
-						value: "initial-request"
-					},
-					":message-type": {
-						type: "string",
-						value: "event"
-					},
-					":content-type": {
-						type: "string",
-						value: defaultContentType
-					}
-				};
-				serializer.write(requestSchema, initialRequest);
-				const body = serializer.flush();
-				yield {
-					[initialRequestMarker]: true,
-					headers,
-					body
-				};
-			}
-			for await (const page of eventStream) yield page;
-		} };
-		return marshaller.serialize(eventStreamIterable, (event) => {
-			if (event[initialRequestMarker]) return {
-				headers: event.headers,
-				body: event.body
-			};
-			let unionMember = "";
-			for (const key in event) if (key !== "__type") {
-				unionMember = key;
-				break;
-			}
-			const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
-			return {
-				headers: {
-					":event-type": {
-						type: "string",
-						value: eventType
-					},
-					":message-type": {
-						type: "string",
-						value: "event"
-					},
-					":content-type": {
-						type: "string",
-						value: explicitPayloadContentType ?? defaultContentType
-					},
-					...additionalHeaders
-				},
-				body
-			};
-		});
-	}
-	async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
-		const marshaller = this.marshaller;
-		const eventStreamMember = responseSchema.getEventStreamMember();
-		const memberSchemas = responseSchema.getMemberSchema(eventStreamMember).getMemberSchemas();
-		const initialResponseMarker = Symbol("initialResponseMarker");
-		const asyncIterable = marshaller.deserialize(response.body, async (event) => {
-			let unionMember = "";
-			for (const key in event) if (key !== "__type") {
-				unionMember = key;
-				break;
-			}
-			const body = event[unionMember].body;
-			if (unionMember === "initial-response") {
-				const dataObject = await this.deserializer.read(responseSchema, body);
-				delete dataObject[eventStreamMember];
-				return {
-					[initialResponseMarker]: true,
-					...dataObject
-				};
-			} else if (unionMember in memberSchemas) {
-				const eventStreamSchema = memberSchemas[unionMember];
-				if (eventStreamSchema.isStructSchema()) {
-					const out = {};
-					let hasBindings = false;
-					for (const [name, member] of eventStreamSchema.structIterator()) {
-						const { eventHeader, eventPayload } = member.getMergedTraits();
-						hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
-						if (eventPayload) {
-							if (member.isBlobSchema()) out[name] = body;
-							else if (member.isStringSchema()) out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8$1)(body);
-							else if (member.isStructSchema()) out[name] = await this.deserializer.read(member, body);
-						} else if (eventHeader) {
-							const value = event[unionMember].headers[name]?.value;
-							if (value != null) if (member.isNumericSchema()) if (value && typeof value === "object" && "bytes" in value) out[name] = BigInt(value.toString());
-							else out[name] = Number(value);
-							else out[name] = value;
-						}
-					}
-					if (hasBindings) return { [unionMember]: out };
-					if (body.byteLength === 0) return { [unionMember]: {} };
-				}
-				return { [unionMember]: await this.deserializer.read(eventStreamSchema, body) };
-			} else return { $unknown: event };
-		});
-		const asyncIterator = asyncIterable[Symbol.asyncIterator]();
-		const firstEvent = await asyncIterator.next();
-		if (firstEvent.done) return asyncIterable;
-		if (firstEvent.value?.[initialResponseMarker]) {
-			if (!responseSchema) throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
-			for (const key in firstEvent.value) initialResponseContainer[key] = firstEvent.value[key];
-		}
-		return { async *[Symbol.asyncIterator]() {
-			if (!firstEvent?.value?.[initialResponseMarker]) yield firstEvent.value;
-			while (true) {
-				const { done, value } = await asyncIterator.next();
-				if (done) break;
-				yield value;
-			}
-		} };
-	}
-	writeEventBody(unionMember, unionSchema, event) {
-		const serializer = this.serializer;
-		let eventType = unionMember;
-		let explicitPayloadMember = null;
-		let explicitPayloadContentType;
-		const isKnownSchema = unionSchema.getSchema()[4].includes(unionMember);
-		const additionalHeaders = {};
-		if (!isKnownSchema) {
-			const [type, value] = event[unionMember];
-			eventType = type;
-			serializer.write(15, value);
-		} else {
-			const eventSchema = unionSchema.getMemberSchema(unionMember);
-			if (eventSchema.isStructSchema()) {
-				for (const [memberName, memberSchema] of eventSchema.structIterator()) {
-					const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
-					if (eventPayload) explicitPayloadMember = memberName;
-					else if (eventHeader) {
-						const value = event[unionMember][memberName];
-						let type = "binary";
-						if (memberSchema.isNumericSchema()) if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) type = "integer";
-						else type = "long";
-						else if (memberSchema.isTimestampSchema()) type = "timestamp";
-						else if (memberSchema.isStringSchema()) type = "string";
-						else if (memberSchema.isBooleanSchema()) type = "boolean";
-						if (value != null) {
-							additionalHeaders[memberName] = {
-								type,
-								value
-							};
-							delete event[unionMember][memberName];
-						}
-					}
-				}
-				if (explicitPayloadMember !== null) {
-					const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
-					if (payloadSchema.isBlobSchema()) explicitPayloadContentType = "application/octet-stream";
-					else if (payloadSchema.isStringSchema()) explicitPayloadContentType = "text/plain";
-					serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
-				} else serializer.write(eventSchema, event[unionMember]);
-			} else if (eventSchema.isUnitSchema()) serializer.write(eventSchema, {});
-			else throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
-		}
-		const messageSerialization = serializer.flush() ?? new Uint8Array();
-		return {
-			body: typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? fromUtf8$1)(messageSerialization) : messageSerialization,
-			eventType,
-			explicitPayloadContentType,
-			additionalHeaders
-		};
-	}
-};
-
-export { EventStreamSerde };
-//# sourceMappingURL=event-streams-Bi2p_fVo.js.map

package/studio-dist/server/chunks/execution-learning-BVCw7Plq.js

@@ -1,278 +0,0 @@
-import { g as getBrainAccessor } from './memory-accessor2-B981tHDR.js';
-import { randomBytes } from 'node:crypto';
-import './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: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/agents/execution-learning.js
-/**
-* Agent Execution Learning — Agent dimension BRAIN integration.
-*
-* Tracks which agent types succeed or fail on which task types, logs agent
-* decisions to brain_decisions with structured context, provides queries to
-* retrieve agent performance history, and implements basic self-healing by
-* recording failure patterns as brain_observations and surfacing healing
-* suggestions when the same failure pattern recurs.
-*
-* This module bridges the agent registry (tasks.db) with the cognitive
-* memory layer (brain.db) without introducing circular dependencies:
-* - Tasks.db agent tables: agent_instances, agent_error_log (agent-schema.ts)
-* - Brain.db tables: brain_decisions, brain_patterns, brain_observations
-*
-* All brain.db writes are best-effort — failures are silently swallowed so
-* agent lifecycle events never fail due to a brain.db write error.
-*
-* @module agents/execution-learning
-* @task T034
-* @epic T029
-*/
-/** Generate a unique brain_decisions ID with `AGT-` prefix. */
-function generateDecisionId() {
-	return `AGT-${randomBytes(5).toString("hex")}`;
-}
-/** Generate a unique brain_patterns ID with `P-agt-` prefix. */
-function generatePatternId() {
-	return `P-agt-${randomBytes(4).toString("hex")}`;
-}
-/** Generate a unique brain_observations ID with `O-agt-` prefix. */
-function generateObservationId() {
-	return `O-agt-${randomBytes(4).toString("hex")}`;
-}
-/** Normalised ISO timestamp in SQLite-friendly format (space separator). */
-function nowSql() {
-	return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-}
-/**
-* Internal implementation that accepts a pre-constructed accessor.
-* Separated for testability without touching the real file system.
-*
-* @internal
-*/
-async function _recordAgentExecutionWithAccessor(event, brain) {
-	const id = generateDecisionId();
-	const outcomeMap = {
-		success: "success",
-		failure: "failure",
-		partial: "mixed"
-	};
-	const decisionText = `Agent type "${event.agentType}" ${event.outcome === "success" ? "successfully completed" : `failed (${event.errorType ?? "unknown"}) on`} task ${event.taskId} (type: ${event.taskType})`;
-	const rationale = [
-		`Agent: ${event.agentId}`,
-		`Task type: ${event.taskType}`,
-		`Outcome: ${event.outcome}`,
-		event.taskLabels?.length ? `Labels: ${event.taskLabels.join(", ")}` : null,
-		event.errorMessage ? `Error: ${event.errorMessage}` : null,
-		event.durationMs != null ? `Duration: ${event.durationMs}ms` : null
-	].filter(Boolean).join(" | ");
-	const alternativesJson = JSON.stringify({
-		agentId: event.agentId,
-		agentType: event.agentType,
-		taskType: event.taskType,
-		taskLabels: event.taskLabels ?? [],
-		errorType: event.errorType ?? null,
-		durationMs: event.durationMs ?? null,
-		sessionId: event.sessionId ?? null
-	});
-	return await brain.addDecision({
-		id,
-		type: "tactical",
-		decision: decisionText,
-		rationale,
-		confidence: event.outcome === "success" ? "high" : event.outcome === "partial" ? "medium" : "low",
-		outcome: outcomeMap[event.outcome],
-		alternativesJson,
-		contextTaskId: event.taskId,
-		contextEpicId: null,
-		contextPhase: null,
-		createdAt: nowSql(),
-		updatedAt: null,
-		decisionCategory: "agent_dispatch"
-	});
-}
-/**
-* Internal implementation with injected accessor.
-*
-* @internal
-*/
-async function _recordFailurePatternWithAccessor(event, brain) {
-	const errorType = event.errorType ?? "unknown";
-	const patternText = `Agent type "${event.agentType}" fails on task type "${event.taskType}" with ${errorType} error`;
-	const contextText = `Failure pattern detected: ${event.agentType} agent encountering ${errorType} errors on ${event.taskType} tasks`;
-	const match = (await brain.findPatterns({
-		type: "failure",
-		limit: 200
-	})).find((p) => p.pattern === patternText);
-	if (match) {
-		const newFrequency = match.frequency + 1;
-		const suggestion = buildHealingSuggestion(event.agentType, event.taskType, errorType, newFrequency);
-		await brain.updatePattern(match.id, {
-			frequency: newFrequency,
-			successRate: 0,
-			mitigation: suggestion
-		});
-		return {
-			...match,
-			frequency: newFrequency,
-			successRate: 0,
-			mitigation: suggestion
-		};
-	}
-	const id = generatePatternId();
-	const now = nowSql();
-	const suggestion = buildHealingSuggestion(event.agentType, event.taskType, errorType, 1);
-	return brain.addPattern({
-		id,
-		type: "failure",
-		pattern: patternText,
-		context: contextText,
-		frequency: 1,
-		successRate: 0,
-		impact: "medium",
-		antiPattern: `${event.agentType} assigned to ${event.taskType} task with ${errorType} error risk`,
-		mitigation: suggestion,
-		examplesJson: JSON.stringify([event.taskId]),
-		extractedAt: now,
-		updatedAt: null
-	});
-}
-/**
-* Internal implementation with injected accessor.
-*
-* @internal
-*/
-async function _storeHealingStrategyWithAccessor(event, strategy, brain) {
-	const id = generateObservationId();
-	const now = nowSql();
-	return brain.addObservation({
-		id,
-		type: "change",
-		title: `Healing strategy: ${event.agentType} on ${event.taskType}`,
-		subtitle: `Error type: ${event.errorType ?? "unknown"}`,
-		narrative: strategy,
-		factsJson: JSON.stringify([
-			`Agent: ${event.agentType}`,
-			`Task type: ${event.taskType}`,
-			`Error: ${event.errorMessage ?? "unspecified"}`,
-			`Suggested action: ${strategy}`
-		]),
-		conceptsJson: JSON.stringify([
-			"self-healing",
-			"agent-execution",
-			event.agentType,
-			event.taskType
-		]),
-		project: null,
-		filesReadJson: null,
-		filesModifiedJson: null,
-		sourceSessionId: event.sessionId ?? null,
-		sourceType: "agent",
-		contentHash: null,
-		discoveryTokens: null,
-		createdAt: now,
-		updatedAt: null
-	});
-}
-/**
-* Internal implementation with injected accessor.
-*
-* @internal
-*/
-async function _getSelfHealingSuggestionsWithAccessor(agentType, taskType, brain) {
-	const patterns = await brain.findPatterns({
-		type: "failure",
-		limit: 200
-	});
-	const prefix = `Agent type "${agentType}" fails on task type "${taskType}"`;
-	return patterns.filter((p) => p.pattern.startsWith(prefix) && p.mitigation).map((p) => ({
-		patternId: p.id,
-		failurePattern: p.pattern,
-		frequency: p.frequency,
-		suggestion: p.mitigation,
-		confidence: Math.min(.3 + p.frequency * .1, .9)
-	})).sort((a, b) => b.frequency - a.frequency);
-}
-/**
-* Full agent lifecycle event processor.
-*
-* Convenience function that:
-* 1. Records the execution event to brain_decisions
-* 2. On failure: records/updates the failure pattern in brain_patterns
-* 3. On failure with frequency ≥ 3: stores a healing strategy observation
-*
-* Returns a structured result with the recorded IDs and any healing
-* suggestions that now apply.
-*
-* All operations are best-effort — the call never throws.
-*
-* @param event - The execution event
-* @param cwd - Working directory
-*/
-async function processAgentLifecycleEvent(event, cwd) {
-	const result = {
-		decisionId: null,
-		patternId: null,
-		observationId: null,
-		healingSuggestions: []
-	};
-	try {
-		const brain = await getBrainAccessor(cwd);
-		const decision = await _recordAgentExecutionWithAccessor(event, brain);
-		if (decision) result.decisionId = decision.id;
-		if (event.outcome === "failure") {
-			const pattern = await _recordFailurePatternWithAccessor(event, brain);
-			if (pattern) {
-				result.patternId = pattern.id;
-				if (pattern.frequency >= 3 && pattern.mitigation) {
-					const obs = await _storeHealingStrategyWithAccessor(event, pattern.mitigation, brain);
-					if (obs) result.observationId = obs.id;
-				}
-			}
-		}
-		if (event.outcome !== "success") result.healingSuggestions = await _getSelfHealingSuggestionsWithAccessor(event.agentType, event.taskType, brain);
-	} catch {}
-	return result;
-}
-/**
-* Build a human-readable healing mitigation string for a failure pattern.
-*/
-function buildHealingSuggestion(agentType, taskType, errorType, frequency) {
-	if (errorType === "retriable") return `Retry with exponential backoff. Consider switching to a different ${agentType} agent instance if failures exceed threshold (seen ${frequency}x).`;
-	if (errorType === "permanent") return `Reassign task to a different agent type — ${agentType} has a permanent failure on ${taskType} tasks. Check permissions, inputs, and dependencies (seen ${frequency}x).`;
-	if (frequency >= 5) return `High-frequency unknown failure (${frequency}x): escalate to orchestrator for manual investigation of ${agentType} on ${taskType} tasks.`;
-	return `Unknown failure for ${agentType} on ${taskType} tasks (${frequency}x). Check agent logs, retry with fresh context, or reassign to a different agent type.`;
-}
-
-export { processAgentLifecycleEvent };
-//# sourceMappingURL=execution-learning-BVCw7Plq.js.map