@cleocode/cleo 2026.9.7 → 2026.9.9

package/studio-dist/server/chunks/brain-writer-handlers-Dwu0QCAA.js

@@ -1,188 +0,0 @@
-import { b as getLogger } from './paths-CV7S5-Zm.js';
-import { join } from 'node:path';
-import { isMainThread } from 'node:worker_threads';
-import 'node:fs';
-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';
-
-//#region ../core/dist/memory/brain-writer-handlers.js
-/**
-* BRAIN writer-thread op handlers.
-*
-* Shared between the worker thread (`brain-writer-worker.ts`) and the
-* inline fallback executor inside `brain-writer-thread.ts`. Each op kind
-* lands here as its terminal SQL/orchestration call; **this is the only
-* module that opens a write handle to brain.db** during normal operation.
-*
-* Read-only callers continue to use `getBrainDb` / `getBrainNativeDb` on
-* the main thread — SQLite WAL allows concurrent readers.
-*
-* @task T10351
-* @epic T10286
-* @saga T10281
-*/
-/**
-* Synchronise the writer's `CLEO_DIR` view with the op's authoritative
-* `projectRoot` when executing inside the brain-writer worker thread.
-*
-* ## Why this is required (cross-thread env staleness)
-*
-* `worker_threads.Worker` receives a *snapshot copy* of `process.env` at spawn
-* time; later mutations on the main thread are NOT propagated to the worker.
-* The persistent brain-writer worker is spawned lazily on the first enqueue and
-* then lives for the rest of the process, so its `process.env['CLEO_DIR']` is
-* frozen to whatever value was set when it spawned.
-*
-* `resolveCleoDir()` gives an absolute `CLEO_DIR` override precedence over the
-* explicitly-passed `cwd` (paths.ts step 2 > step 3). Inside the worker, that
-* stale absolute override therefore wins over the op's `projectRoot`, so every
-* downstream `getDb()` / `resolveCleoDir()` (e.g. the cross-db session
-* write-guard in `observeBrain`) resolves to the WRONG `.cleo` directory —
-* silently dropping cross-db references such as `sourceSessionId`.
-*
-* Each write op already carries its authoritative `projectRoot`, so on the
-* worker thread we re-point `CLEO_DIR` to `<projectRoot>/.cleo` before
-* dispatching — exactly mirroring the value the main thread holds. On the main
-* thread (inline-fallback executor) we leave `process.env` untouched: its
-* `CLEO_DIR` is already authoritative and must not be clobbered.
-*
-* @param projectRoot - The op's authoritative project root.
-*/
-function syncWorkerCleoDir(projectRoot) {
-	if (isMainThread) return;
-	process.env["CLEO_DIR"] = join(projectRoot, ".cleo");
-}
-/**
-* Dispatch a write op to its terminal handler. Throws on failure — the worker
-* envelope code converts the throw into an `ok:false` response.
-*
-* @param op - The discriminated write op.
-* @returns A typed `BrainWriteResult` mirroring the op's `kind`.
-*/
-async function handleWriteOp(op) {
-	syncWorkerCleoDir(op.projectRoot);
-	switch (op.kind) {
-		case "observe": return handleObserve(op);
-		case "decision": return handleDecision(op);
-		case "learning": return handleLearning(op);
-		case "plasticity_event": return handlePlasticityEvent(op);
-		case "weight_update": return handleWeightUpdate(op);
-		case "dialectic": return handleDialectic(op);
-		default: throw new Error(`Unknown BrainWriteOp kind: ${JSON.stringify(op)}`);
-	}
-}
-async function handleObserve(op) {
-	const { observeBrain } = await import('./observe-Bo9veHGe.js');
-	return {
-		kind: "observe",
-		result: await observeBrain(op.projectRoot, {
-			...op.params,
-			_skipQueue: true
-		})
-	};
-}
-async function handleDecision(op) {
-	const { getBrainAccessor } = await import('./memory-accessor-i3P-RHSg.js');
-	return {
-		kind: "decision",
-		id: (await (await getBrainAccessor(op.projectRoot)).addDecision(op.row)).id
-	};
-}
-async function handleLearning(op) {
-	const { getBrainAccessor } = await import('./memory-accessor-i3P-RHSg.js');
-	return {
-		kind: "learning",
-		id: (await (await getBrainAccessor(op.projectRoot)).addLearning(op.row)).id
-	};
-}
-async function handlePlasticityEvent(op) {
-	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(op.projectRoot);
-	const nativeDb = getBrainNativeDb(op.projectRoot);
-	if (!nativeDb) throw new Error("brain native DB unavailable for plasticity_event op");
-	const result = nativeDb.prepare(`INSERT INTO brain_plasticity_events
-       (source_node, target_node, delta_w, kind, timestamp,
-        session_id, retrieval_log_id, weight_before, weight_after, delta_t_ms)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(op.sourceNode, op.targetNode, op.deltaW, op.eventKind, op.timestamp, op.sessionId, op.retrievalLogId, op.weightBefore, op.weightAfter, op.deltaTms);
-	return {
-		kind: "plasticity_event",
-		lastInsertRowid: typeof result.lastInsertRowid === "bigint" ? Number(result.lastInsertRowid) : typeof result.lastInsertRowid === "number" ? result.lastInsertRowid : null
-	};
-}
-async function handleWeightUpdate(op) {
-	const { getBrainDb, getBrainNativeDb } = await import('./memory-sqlite2-B7dq8doO.js');
-	await getBrainDb(op.projectRoot);
-	const nativeDb = getBrainNativeDb(op.projectRoot);
-	if (!nativeDb) throw new Error("brain native DB unavailable for weight_update op");
-	try {
-		nativeDb.prepare("SELECT 1 FROM brain_weight_history LIMIT 1").get();
-	} catch {
-		return {
-			kind: "weight_update",
-			ok: true
-		};
-	}
-	nativeDb.prepare(`INSERT INTO brain_weight_history
-       (edge_from_id, edge_to_id, edge_type, weight_before, weight_after,
-        delta_weight, event_kind, source_plasticity_event_id, retrieval_log_id,
-        reward_signal, changed_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(op.edgeFromId, op.edgeToId, op.edgeType, op.weightBefore, op.weightAfter, op.deltaWeight, op.eventKind, op.sourcePlasticityEventId, op.retrievalLogId, op.rewardSignal, op.changedAt);
-	return {
-		kind: "weight_update",
-		ok: true
-	};
-}
-async function handleDialectic(op) {
-	const log = getLogger("brain-writer");
-	const sourceTag = `dialectic:${op.sessionId}`;
-	for (const insight of op.insights.peerInsights) try {
-		const { observeBrain } = await import('./observe-Bo9veHGe.js');
-		await observeBrain(op.projectRoot, {
-			text: `[${insight.key}] ${insight.value}`,
-			title: insight.key,
-			sourceSessionId: op.sessionId,
-			sourceType: "agent",
-			agent: op.activePeerId,
-			sourceConfidence: insight.confidence >= .8 ? "task-outcome" : "agent",
-			_skipQueue: true
-		});
-	} catch (err) {
-		log.warn({
-			err,
-			sourceTag,
-			key: insight.key
-		}, "dialectic peer insight write failed");
-	}
-	if (op.insights.sessionNarrativeDelta) try {
-		const { appendNarrativeDelta } = await import('./session-narrative-BirZINSU.js');
-		await appendNarrativeDelta(op.sessionId, op.insights.sessionNarrativeDelta, op.projectRoot);
-	} catch (err) {
-		log.warn({
-			err,
-			sourceTag
-		}, "dialectic narrative delta write failed");
-	}
-	return {
-		kind: "dialectic",
-		ok: true
-	};
-}
-
-export { handleWriteOp };
-//# sourceMappingURL=brain-writer-handlers-Dwu0QCAA.js.map

package/studio-dist/server/chunks/brain-writer-thread-6n7wI7Gy.js

@@ -1,360 +0,0 @@
-import { b as getLogger } from './paths-CV7S5-Zm.js';
-import { r as resolveDualScopeDbPath, g as resolveLeaseMode, h as acquireWriterLease, j as assertWriterLeaseHeld } from './dual-scope-db-DKnWu1KM.js';
-import { existsSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-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 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-
-//#region ../core/dist/memory/brain-writer-thread.js
-/**
-* BRAIN single-writer chokepoint — main-thread queue manager.
-*
-* All hot-path writes to `brain.db` MUST route through `enqueueBrainWrite` so
-* that a single Node.js `worker_threads.Worker` owns the only write handle and
-* serializes every INSERT/UPDATE through one consumer. This eliminates the
-* within-process race documented in the T10301 RCA (page-1 sqlite_schema
-* B-tree corruption caused by concurrent setImmediate writers + dialectic-hook
-* + propose-tick reconciler + STDP plasticity loop all opening their own
-* `getBrainDb` singletons).
-*
-* ## Architecture
-*
-*  Main thread                         Worker thread
-*  ───────────                         ─────────────
-*  enqueueBrainWrite(op)               (owns getBrainDb handle)
-*        │                                    ▲
-*        ▼                                    │ MessagePort
-*  pendingRequests[seq] = {resolve, reject}   │
-*        │                                    │
-*        └──── postMessage({seq, op}) ────────┘
-*                                             │
-*                                             ▼
-*                                       handleWriteOp(op)
-*                                       (SQL INSERT/UPDATE)
-*                                             │
-*        ┌──── postMessage({seq, ok, ...})────┘
-*        ▼
-*  resolve(...) → caller's await
-*
-* Reads continue to use `getBrainDb` / `getBrainNativeDb` directly. SQLite WAL
-* permits concurrent readers; only writes must be funneled.
-*
-* ## Bypass mechanism
-*
-* Forensic / one-shot scripts that need a direct write handle can set
-* `CLEO_BRAIN_BYPASS_WRITER_THREAD=1`. Each call to `enqueueBrainWrite` then
-* executes the op inline on the main thread. **A Pino warn is emitted on every
-* bypass** (audit trail per AC #5).
-*
-* @task T10351
-* @epic T10286
-* @saga T10281
-*/
-/**
-* Check whether the bypass env var is set. Emits a Pino warn on every call
-* so the audit trail is preserved (AC #5).
-*/
-function bypassEnabled() {
-	if (process.env["CLEO_BRAIN_BYPASS_WRITER_THREAD"] === "1") {
-		getLogger("brain-writer").warn({
-			event: "bypass-active",
-			envVar: "CLEO_BRAIN_BYPASS_WRITER_THREAD"
-		}, "Brain writer-thread chokepoint bypassed via env var — direct main-thread write");
-		return true;
-	}
-	return false;
-}
-/**
-* Resolve the absolute path to the compiled brain-writer-worker script.
-*
-* Strategy:
-*  1. Adjacent to this file (`memory/brain-writer-worker.js`)
-*  2. Fallback null when not found (esbuild bundle context, tests, etc.)
-*/
-function resolveWorkerPath() {
-	try {
-		const candidate = join(dirname(fileURLToPath(import.meta.url)), "brain-writer-worker.js");
-		if (existsSync(candidate)) return candidate;
-		return null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Singleton writer-thread manager. One worker per process, owns the only
-* brain.db write handle. Reads remain on the main thread via `getBrainDb`.
-*/
-var BrainWriterManager = class {
-	worker = null;
-	workerReady = false;
-	workerInitError = null;
-	initPromise = null;
-	pending = /* @__PURE__ */ new Map();
-	seqCounter = 0;
-	shuttingDown = false;
-	/** Lazy-initialize the worker thread on first enqueue. */
-	async ensureWorker() {
-		if (this.workerReady || this.shuttingDown) return;
-		if (this.workerInitError) throw this.workerInitError;
-		if (this.initPromise) return this.initPromise;
-		this.initPromise = this.doInit();
-		try {
-			await this.initPromise;
-		} finally {
-			this.initPromise = null;
-		}
-	}
-	async doInit() {
-		const workerPath = resolveWorkerPath();
-		if (!workerPath) {
-			this.workerInitError = /* @__PURE__ */ new Error("brain-writer-worker.js not found adjacent to brain-writer-thread.js");
-			throw this.workerInitError;
-		}
-		const { Worker } = await import('node:worker_threads');
-		const worker = new Worker(workerPath);
-		worker.on("message", (msg) => {
-			this.handleWorkerMessage(msg);
-		});
-		worker.on("error", (err) => {
-			for (const [, req] of this.pending) req.reject(err instanceof Error ? err : new Error(String(err)));
-			this.pending.clear();
-			this.worker = null;
-			this.workerReady = false;
-			this.workerInitError = err instanceof Error ? err : new Error(String(err));
-			getLogger("brain-writer").error({ err }, "Brain writer-thread crashed");
-		});
-		worker.on("exit", (code) => {
-			this.worker = null;
-			this.workerReady = false;
-			if (code !== 0 && !this.shuttingDown) {
-				const err = /* @__PURE__ */ new Error(`brain-writer-worker exited with code ${code}`);
-				for (const [, req] of this.pending) req.reject(err);
-				this.pending.clear();
-				this.workerInitError = err;
-			}
-		});
-		this.worker = worker;
-		this.workerReady = true;
-	}
-	handleWorkerMessage(msg) {
-		const pending = this.pending.get(msg.seq);
-		if (!pending) return;
-		this.pending.delete(msg.seq);
-		if (msg.ok) pending.resolve(msg.result);
-		else pending.reject(new Error(msg.error));
-	}
-	/**
-	* Enqueue a write op. Returns a promise that resolves with the worker's
-	* result envelope payload (shape depends on op kind).
-	*/
-	async enqueue(op) {
-		if (this.shuttingDown) throw new Error("brain-writer is shutting down — no new writes accepted");
-		await this.ensureWorker();
-		const worker = this.worker;
-		if (!worker) throw new Error("brain-writer worker is not available");
-		const seq = ++this.seqCounter;
-		const envelope = {
-			seq,
-			op
-		};
-		return new Promise((resolve, reject) => {
-			this.pending.set(seq, {
-				resolve,
-				reject
-			});
-			try {
-				worker.postMessage(envelope);
-			} catch (err) {
-				this.pending.delete(seq);
-				reject(err instanceof Error ? err : new Error(String(err)));
-			}
-		});
-	}
-	/** Drain pending work and terminate the worker. Idempotent. */
-	async shutdown() {
-		if (this.shuttingDown) return;
-		this.shuttingDown = true;
-		const grace = 250;
-		const started = Date.now();
-		while (this.pending.size > 0 && Date.now() - started < grace) await new Promise((r) => setTimeout(r, 25));
-		if (this.worker) {
-			try {
-				await this.worker.terminate();
-			} catch {}
-			this.worker = null;
-		}
-		this.workerReady = false;
-		this.pending.clear();
-	}
-	/** @internal — test helper */
-	_hasInFlight() {
-		return this.pending.size;
-	}
-};
-/**
-* The cleo.db scope the brain WRITE handle targets. `getBrainDb()` routes through
-* `openDualScopeDb('project')` (memory-sqlite.ts T11522) — the `brain_*` tables
-* live in the consolidated PROJECT `cleo.db`, co-located with `tasks_*`. So the
-* brain lane is leased in the `'project'` scope.
-*/
-var BRAIN_LEASE_SCOPE = "project";
-/** The dedicated brain write lane (AC4 — held independently of the `tasks` chokepoint). */
-var BRAIN_LEASE_LANE = "brain";
-/** Batch grants keyed by the concrete project `cleo.db` path. */
-var _brainBatches = /* @__PURE__ */ new Map();
-/**
-* Acquire (or re-enter) the batch-granularity `brain` lease for the duration of a
-* single `enqueueBrainWrite`. The first in-flight call acquires the lease;
-* concurrent calls share it (refcount) — including callers that race the FIRST
-* acquire, which single-flight onto the same in-flight promise rather than each
-* running a full acquire. The lease is released when the last in-flight call
-* finishes (refcount → 0). In `off` mode this is a no-op pass-through (no lease,
-* `busy_timeout` serializes as before).
-*
-* @returns A release callback the caller MUST invoke (in a `finally`) when its
-*   write completes; the underlying row is freed only when the batch quiesces.
-*/
-async function enterBrainBatchLease(dbPath) {
-	if (resolveLeaseMode() === "off") return async () => {};
-	let state = _brainBatches.get(dbPath);
-	if (state === void 0) {
-		state = {
-			handle: null,
-			refcount: 0,
-			inflight: null
-		};
-		_brainBatches.set(dbPath, state);
-	}
-	if (state.handle === null) {
-		if (state.inflight === null) state.inflight = acquireWriterLease(BRAIN_LEASE_SCOPE, BRAIN_LEASE_LANE, {
-			priority: 50,
-			dbPath
-		});
-		const inflight = state.inflight;
-		try {
-			const handle = await inflight;
-			if (state.handle === null) state.handle = handle;
-		} finally {
-			if (state.inflight === inflight) state.inflight = null;
-		}
-	}
-	state.refcount += 1;
-	let released = false;
-	return async () => {
-		if (released) return;
-		released = true;
-		state.refcount -= 1;
-		if (state.refcount <= 0 && state.handle !== null) {
-			const handle = state.handle;
-			state.handle = null;
-			state.refcount = 0;
-			if (_brainBatches.get(dbPath) === state) _brainBatches.delete(dbPath);
-			await handle.release();
-		}
-	};
-}
-/**
-* Async mutex used by the inline fallback path so that bypass-mode writes
-* (and the test-env path where the worker file is unavailable) still
-* serialize within the process. Without this guard, the bypass would
-* reintroduce the very race condition the chokepoint exists to eliminate.
-*/
-var inlineQueueTail = Promise.resolve();
-function runInline(op) {
-	const next = inlineQueueTail.then(() => executeInline(op));
-	inlineQueueTail = next.catch(() => void 0);
-	return next;
-}
-/**
-* Inline executor — imports the worker's handler module dynamically and runs
-* the op on the main thread. Used by:
-*  - bypass mode (`CLEO_BRAIN_BYPASS_WRITER_THREAD=1`)
-*  - worker-unavailable contexts (tests, esbuild bundle context)
-*
-* The handler module is shared between the worker thread and this fallback,
-* so behaviour is identical except for the thread of execution.
-*/
-async function executeInline(op) {
-	assertWriterLeaseHeld(BRAIN_LEASE_SCOPE, BRAIN_LEASE_LANE, resolveDualScopeDbPath(BRAIN_LEASE_SCOPE, op.projectRoot));
-	const { handleWriteOp } = await import('./brain-writer-handlers-Dwu0QCAA.js');
-	return handleWriteOp(op);
-}
-var _manager = null;
-function getManager() {
-	if (!_manager) {
-		_manager = new BrainWriterManager();
-		process.on("exit", () => {
-			_manager?.shutdown().catch(() => void 0);
-		});
-		const gracefulShutdown = () => {
-			const deadline = setTimeout(() => process.exit(0), 2e3);
-			deadline.unref();
-			_manager?.shutdown().catch(() => void 0).finally(() => {
-				clearTimeout(deadline);
-			});
-		};
-		process.once("SIGTERM", gracefulShutdown);
-		process.once("SIGINT", gracefulShutdown);
-	}
-	return _manager;
-}
-/**
-* Enqueue a brain.db write op through the single-writer chokepoint.
-*
-* Resolves with the typed result for the op's `kind`. Rejects when:
-*  - the op fails inside the worker (worker forwards the error message)
-*  - the worker crashes (the in-flight promise rejects with the worker error)
-*  - bypass mode is on AND the inline execution fails
-*
-* @example
-* ```ts
-* const result = await enqueueBrainWrite({
-*   kind: 'observe',
-*   projectRoot: '/path/to/project',
-*   params: { text: 'Decided X over Y', sourceType: 'manual' },
-* });
-* if (result.kind === 'observe') {
-*   console.log('Stored observation', result.result.id);
-* }
-* ```
-*
-* @param op - The write op (discriminated by `kind`).
-* @returns Worker result for the op.
-*/
-async function enqueueBrainWrite(op) {
-	const releaseBatch = await enterBrainBatchLease(resolveDualScopeDbPath(BRAIN_LEASE_SCOPE, op.projectRoot));
-	try {
-		if (bypassEnabled()) return await runInline(op);
-		try {
-			return await getManager().enqueue(op);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			getLogger("brain-writer").debug({ err: msg }, "Brain writer-thread unavailable — falling back to inline serialized executor");
-			return await runInline(op);
-		}
-	} finally {
-		await releaseBatch();
-	}
-}
-
-export { enqueueBrainWrite };
-//# sourceMappingURL=brain-writer-thread-6n7wI7Gy.js.map