Function bodies 413 total

	private rerank(fragments: MemoryFragment[]): MemoryFragment[] {
		const now = Date.now();

		for (const frag of fragments) {
			// Base: 1 - distance (ChromaDB L2 normalized cosine → lower distance = more similar)
			const baseSimilarity = 1 - frag.rawDistance;

			// Freshness bonus: recent docs get up to MAX_FRESHNESS_BONUS
			let freshnessBonus = 0;
			if (frag.createdAt) {
				const ageMs = now - new Date(frag.createdAt).getTime();
				if (ageMs >= 0 && ageMs < FRESHNESS_WINDOW_MS) {
					const recency = 1 - ageMs / FRESHNESS_WINDOW_MS;
					freshnessBonus = Math.min(MAX_FRESHNESS_BONUS, recency * MAX_FRESHNESS_BONUS);
				}
			}

			// Identity source prior
			const identityBonus = frag.collection === 'beau_identity' ? IDENTITY_SOURCE_BONUS : 0;

			frag.finalScore = baseSimilarity + freshnessBonus + identityBonus;
		}

		// Sort descending by finalScore
		fragments.sort((a, b) => b.finalScore - a.finalScore);
		return fragments;
	}

	private trimToBudget(fragments: MemoryFragment[], maxTokens: number): MemoryFragment[] {
		const result: MemoryFragment[] = [];
		let used = 0;

		for (const frag of fragments) {
			if (used + frag.tokenCount > maxTokens) continue;
			result.push(frag);
			used += frag.tokenCount;
		}

		return result;
	}

	private buildProvenance(
		ranked: MemoryFragment[],
		selectedIds: Set<string>,
	): RetrievalProvenance[] {
		return ranked.map((frag, index) => ({
			fragmentId: frag.id,
			collection: frag.collection,
			sourceType: frag.source,
			sourceEntityId: frag.entityId,
			rank: index,
			baseScore: 1 - frag.rawDistance,
			finalScore: frag.finalScore,
			selected: selectedIds.has(frag.id),
			tokenCount: frag.tokenCount,
			excerptHash: createHash('sha256').update(frag.text).digest('hex'),
		}));
	}

export function collectionForSource(source: SourceType): CollectionName {
	return SOURCE_TO_COLLECTION[source];
}

export function estimateTokens(text: string): number {
	return Math.ceil(text.length / 4);
}

export function formatFragments(fragments: MemoryFragment[]): string {
	return fragments.map((f) => `[${f.source}] ${f.text}`).join('\n');
}

export function subscribeToState(fn: (state: BeauState) => void) {
  listeners.add(fn);
  fn({ ...state });
  return () => listeners.delete(fn);
}

export function getState(): BeauState {
  return { ...state };
}

export function patchState(patch: Partial<BeauState>) {
  state = { ...state, ...patch };
  broadcast();
}

function broadcast() {
  for (const fn of listeners) fn({ ...state });
}

export function publishToMQTT(topic: string, message: string) {
  _publish?.(topic, message);
}

function backfillDispatcherLog() {
  try {
    const recent = db.select({ querySummary: dispatches.querySummary })
      .from(dispatches)
      .orderBy(desc(dispatches.id))
      .limit(100)
      .all()
      .reverse();
    state = {
      ...state,
      dispatcherLog: recent
        .filter((r) => r.querySummary)
        .map((r) => r.querySummary as string),
    };
  } catch (err) {
    console.warn('[bridge] dispatcher backfill skipped:', (err as Error).message);
  }
}

function logEnvironmentEvent(eventType: string, payload: Record<string, unknown>, source: string) {
  try {
    db.insert(environmentEvents).values({
      eventType,
      payloadJson: JSON.stringify(payload),
      source,
    }).run();
  } catch { /* non-fatal */ }
}

function maybeWriteSnapshot() {
  const now = Date.now();
  if (now - lastSnapshotTime < SNAPSHOT_MIN_INTERVAL) return;
  lastSnapshotTime = now;
  try {
    db.insert(environmentSnapshots).values({
      presenceState: state.presenceState || null,
      occupancyConfidence: null,
      lux: state.lux,
      sleepState: state.sleepState || null,
      weatherJson: state.weather ? JSON.stringify(state.weather) : null,
      seasonalSummary: state.seasonalContext || null,
      contextMode: state.mode || null,
    }).run();
  } catch { /* non-fatal */ }
}

  function vectorToEmotionalState(v: { wonder: number; reflection: number; mischief: number }): string {
    const dominant = Math.max(v.wonder, v.reflection, v.mischief);
    if (dominant === v.reflection) return dominant > 0.6 ? 'reflective' : 'contemplative';
    if (dominant === v.mischief) return dominant > 0.6 ? 'mischievous' : 'playful';
    return dominant > 0.6 ? 'wonder' : 'curious';
  }

  function updateFaceState() {
    const faceState = resolveFaceState(state, interactionSignals);
    const glow = resolveGlowWithOverlay(faceState, thoughtQueue.getReadyThoughtType());
    state = { ...state, faceState, glow };
    // Note: do NOT call broadcast() here — the MQTT message handler's
    // existing broadcast() at the end of the switch handles it.
    // For personality engine calls, broadcast() is called after state assignment.
  }

  function refreshActivityCache() {
    const cutoff30min = new Date(Date.now() - 30 * 60 * 1000);
    const cutoffText = cutoff30min.toISOString().replace('T', ' ').slice(0, 19);
    try {
      // haikus.createdAt is integer (timestamp mode) — compare with Date object
      activityCache.haikuRecent = !!db.select({ id: haikus.id })
        .from(haikus).where(gte(haikus.createdAt, cutoff30min)).limit(1).get();

      // journalEntries.createdAt is text (datetime format)
      activityCache.journalRecent = !!db.select({ id: journalEntries.id })
        .from(journalEntries).where(gte(journalEntries.createdAt, cutoffText)).limit(1).get();

      // dispatches.createdAt is text (datetime format)
      activityCache.dispatchRecent = !!db.select({ id: dispatches.id })
        .from(dispatches).where(gte(dispatches.createdAt, cutoffText)).limit(1).get();

      // ideas table has no timestamp column — always false
      activityCache.ideaRecent = false;

      // noticings.createdAt is tex

export function isNotable(
	vector: PersonalityVector,
	previousVector: PersonalityVector,
	hasCreativeActivity: boolean,
	hadModeTransition: boolean,
): boolean {
	// Extreme state check
	const dims: (keyof PersonalityVector)[] = ['wonder', 'reflection', 'mischief'];
	for (const dim of dims) {
		if (vector[dim] > 0.85 || vector[dim] < 0.15) return true;
	}

	// Large delta check
	for (const dim of dims) {
		if (Math.abs(vector[dim] - previousVector[dim]) > 0.2) return true;
	}

	// Activity / transition flags
	if (hasCreativeActivity) return true;
	if (hadModeTransition) return true;

	return false;
}

export function getRetentionTier(timestamp: Date, now: Date): RetentionTier {
	const ageMs = now.getTime() - timestamp.getTime();
	if (ageMs < TIER_HOT_MS)  return 'hot';
	if (ageMs < TIER_WARM_MS) return 'warm';
	if (ageMs < TIER_COOL_MS) return 'cool';
	return 'cold';
}

function toSQLiteTs(d: Date): string {
	return d.toISOString().replace('T', ' ').slice(0, 19);
}

export function runCompaction(db: DrizzleDB): void {
	const now = new Date();
	const hotCutoff  = new Date(now.getTime() - TIER_HOT_MS);
	const warmCutoff = new Date(now.getTime() - TIER_WARM_MS);
	const coolCutoff = new Date(now.getTime() - TIER_COOL_MS);

	const hotCutoffTs  = toSQLiteTs(hotCutoff);
	const warmCutoffTs = toSQLiteTs(warmCutoff);
	const coolCutoffTs = toSQLiteTs(coolCutoff);

	// ── warm tier: keep hourly peaks ─────────────────────────────────────────
	// Fetch all non-notable warm-tier rows
	const warmRows = db.select({
		id: personalitySnapshots.id,
		timestamp: personalitySnapshots.timestamp,
		wonder: personalitySnapshots.wonder,
		reflection: personalitySnapshots.reflection,
		mischief: personalitySnapshots.mischief,
	})
	.from(personalitySnapshots)
	.where(
		and(
			lt(personalitySnapshots.timestamp, hotCutoffTs),
			gte(personalitySnapshots.timestamp, warmCutoffTs),
			eq(personalitySnapshots.isNotable, 0),
		),
	)
	.all();

	// Group by hour, identify peak (h

export function exportPersonalityTimeline(db: DrizzleDB, outputPath: string): void {
	const { writeFileSync } = await_import_sync();

	const now = new Date();
	const rows = db.select().from(personalitySnapshots).all();

	const tierCounts: TierCounts = { hot: 0, warm: 0, cool: 0, cold: 0 };
	const snapshots = rows.map((row) => {
		const tier = getRetentionTier(new Date(row.timestamp), now);
		tierCounts[tier]++;
		return {
			id:               row.id,
			timestamp:        row.timestamp,
			tier,
			wonder:           row.wonder,
			reflection:       row.reflection,
			mischief:         row.mischief,
			derivedMode:      row.derivedMode,
			interpretation:   row.interpretation ?? null,
			isNotable:        row.isNotable,
			snapshotReason:   row.snapshotReason,
		};
	});

	const dateStr = now.toISOString().slice(0, 10);
	const filename = `personality-export-${dateStr}.json`;
	const fullPath = join(outputPath, filename);

	mkdirSync(outputPath, { recursive: true });

	const payload: Person

function await_import_sync() {
	// eslint-disable-next-line @typescript-eslint/no-require-imports
	const { writeFileSync } = require('fs') as typeof import('fs');
	return { writeFileSync };
}

export function scheduleBackup(
	sqliteInstance: { backup: (destination: string) => Promise<void> },
	backupPath: string,
	intervalMs: number,
): () => void {
	mkdirSync(backupPath, { recursive: true });

	const doBackup = async () => {
		const now = new Date();
		const dateStr = now.toISOString().slice(0, 10);                   // YYYY-MM-DD
		const hour    = now.toISOString().slice(11, 13);                  // HH
		const filename = `beau-backup-${dateStr}-${hour}.db`;
		const filepath = join(backupPath, filename);
		try {
			await sqliteInstance.backup(filepath);
		} catch (err) {
			console.error('[personality/compaction] Backup failed:', err);
		}
	};

	const handle = setInterval(doBackup, intervalMs);

	return () => clearInterval(handle);
}

export function envelopeDistance(v: PersonalityVector, env: ModeEnvelope): number {
	const dW = Math.max(0, env.wonder.min - v.wonder, v.wonder - env.wonder.max);
	const dR = Math.max(0, env.reflection.min - v.reflection, v.reflection - env.reflection.max);
	const dM = Math.max(0, env.mischief.min - v.mischief, v.mischief - env.mischief.max);
	return Math.sqrt(dW * dW + dR * dR + dM * dM);
}

export function findDominantDeviation(
	v: PersonalityVector,
	env: ModeEnvelope,
): { dimension: 'wonder' | 'reflection' | 'mischief'; distance: number; sign: -1 | 1 } | null {

export function computeDiscomfort(envDistance: number, persistenceMs: number): number {
	const envComponent = Math.min(1.0, envDistance / ENVELOPE_DISTANCE_CAP);
	const persComponent = Math.min(1.0, persistenceMs / PERSISTENCE_CAP_MS);
	return ENVELOPE_WEIGHT * envComponent + PERSISTENCE_WEIGHT * persComponent;
}

export function computeEnvelopeDistanceWithGrace(
	vector: PersonalityVector,
	currentMode: string,
	candidateMode: string | null,
): number {
	const currentEnv = MODE_ENVELOPES[currentMode];
	if (!currentEnv) return 0;
	const currentDist = envelopeDistance(vector, currentEnv);
	if (candidateMode) {
		const candidateEnv = MODE_ENVELOPES[candidateMode];
		if (candidateEnv) return Math.min(currentDist, envelopeDistance(vector, candidateEnv));
	}
	return currentDist;
}

export function createDiscomfortState(): DiscomfortState {
	return {
		score: 0,
		envelopeDistance: 0,
		persistenceMs: 0,
		coefficient: 1.0,
		dominantDimension: null,
		consecutiveHighTicks: 0,
		consecutiveLowTicks: 0,
		peakCoefficient: 1.0,
	};
}

export function updateDiscomfortState(
	state: DiscomfortState,
	vector: PersonalityVector,
	currentMode: string,
	candidateMode: string | null,
	tickMs: number,
): void {
	// 1. Envelope distance (with grace for pending mode transitions)
	state.envelopeDistance = computeEnvelopeDistanceWithGrace(vector, currentMode, candidateMode);

	// 2. Persistence accumulation
	if (state.envelopeDistance > 0) {
		state.persistenceMs += tickMs;
	} else {
		state.persistenceMs = 0;
	}

	// 3. Composite discomfort score
	state.score = computeDiscomfort(state.envelopeDistance, state.persistenceMs);

	// 4. Dominant dimension
	const currentEnv = MODE_ENVELOPES[currentMode];
	if (currentEnv) {
		const dom = findDominantDeviation(vector, currentEnv);
		state.dominantDimension = dom?.dimension ?? null;
	}

	// 5. Consecutive tick counters
	state.consecutiveHighTicks = state.score > 0.5 ? state.consecutiveHighTicks + 1 : 0;
	state.consecutiveLowTicks = state.score < 0.1 ? state.consecutiveLowTicks + 1 : 0;

function cloneVec(v: PersonalityVector): PersonalityVector {
	return { wonder: v.wonder, reflection: v.reflection, mischief: v.mischief };
}

function maxDelta(a: PersonalityVector, b: PersonalityVector): number {
	return Math.max(
		Math.abs(a.wonder - b.wonder),
		Math.abs(a.reflection - b.reflection),
		Math.abs(a.mischief - b.mischief),
	);
}

export class PersonalityEngine {
	private config: EngineConfig;
	private signal: PersonalityVector;
	private momentum: PersonalityVector;
	private output: PersonalityVector;
	private classifier: ModeClassifier;
	private interpretation = '';
	private listeners: Array<(v: PersonalityVector) => void> = [];
	private lastSnapshot: EngineSnapshot | null = null;
	private lastSnapshotOutput: PersonalityVector;
	private tickCount = 0;
	private intervalId: ReturnType<typeof setInterval> | null = null;
	private discomfortState: DiscomfortState;
	private lastSelfRegResult: SelfRegulationResult | null = null;

	constructor(config: Partial<EngineConfig> = {}) {
		this.config = { ...DEFAULT_CONFIG, ...config };
		const baseline = cloneVec(this.config.restingBaseline);
		this.signal = cloneVec(baseline);
		this.momentum = cloneVec(baseline);
		this.output = cloneVec(baseline);
		this.lastSnapshotOutput = cloneVec(baseline);
		this.classifier = new ModeClassifier();
		this.discomfortState = createDisco

	constructor(config: Partial<EngineConfig> = {}) {
		this.config = { ...DEFAULT_CONFIG, ...config };
		const baseline = cloneVec(this.config.restingBaseline);
		this.signal = cloneVec(baseline);
		this.momentum = cloneVec(baseline);
		this.output = cloneVec(baseline);
		this.lastSnapshotOutput = cloneVec(baseline);
		this.classifier = new ModeClassifier();
		this.discomfortState = createDiscomfortState();
	}

	tick(sensor: SensorState, activity: ActivitySignals): void {
		const targets = computeSignalTargets(sensor, activity);
		const cfg = this.config;
		const alphas = cfg.signalAlphas;

		// (a.5) Self-regulation controller (uses previous tick's output as the vector to evaluate)
		const selfReg = computeSelfRegulation(this.output, this.classifier.currentMode, this.discomfortState);
		this.lastSelfRegResult = selfReg;

		// Merge self-regulation deltas into targets, re-clamp to [0, 1]
		targets.wonder     = Math.max(0, Math.min(1, targets.wonder     + selfReg.deltas.wonder));
		targets.reflection = Math.max(0, Math.min(1, targets.reflection + selfReg.deltas.reflection));
		targets.mischief   = Math.max(0, Math.min(1, targets.mischief   + selfReg.deltas.mischief));
		targets.sources.push(...selfReg.sources);

		// (a) EMA: signal layer toward targets
		this.signal.wonder     = (1 - alphas.wonder)     * this.signal.wonder     + alphas.wonder     * targets.wonder;
		this.signal.reflection = (

	start(
		getSensor: () => SensorState,
		getActivity: () => ActivitySignals,
	): void {
		if (this.intervalId) return;
		this.intervalId = setInterval(() => {
			this.tick(getSensor(), getActivity());
		}, this.config.tickInterval);
	}

	stop(): void {
		if (this.intervalId) {
			clearInterval(this.intervalId);
			this.intervalId = null;
		}
	}

	onVectorChange(callback: (vector: PersonalityVector) => void): void {
		this.listeners.push(callback);
	}

	getLastSnapshot(): EngineSnapshot | null {
		const s = this.lastSnapshot;
		this.lastSnapshot = null; // consume — bridge reads once then clears
		return s;
	}

	getDiscomfortState(): DiscomfortState {
		return { ...this.discomfortState };
	}

	getLastSelfRegResult(): SelfRegulationResult | null {
		return this.lastSelfRegResult;
	}

	resetSelfReflectionTrigger(): void {
		this.discomfortState.consecutiveHighTicks = 0;
	}

	restoreMomentum(vector: PersonalityVector): void {
		this.momentum = cloneVec(vector);
	}

	forceMode(mode: string, reason: string): void {
		console.warn(`[PersonalityEngine] forceMode(${mode}) — reason: ${reason}`);
		this.classifier.previousMode = this.classifier.currentMode;
		this.classifier.currentMode = mode;
	}

	async reflect(): Promise<null> {
		// TODO-B: LLM reflection will replace this — see §17 of beaus-bible.md
		return null;
	}

function getTier(value: number): Tier {
	if (value < 0.25) return 'quiet';
	if (value < 0.5)  return 'present';
	if (value < 0.75) return 'strong';
	return 'intense';
}

function pick<T>(pool: readonly T[], vector: PersonalityVector, salt: number = 0): T {
	const hash = Math.floor(
		(vector.wonder * 1000 + vector.reflection * 100 + vector.mischief * 10 + salt) % pool.length,
	);
	const idx = Math.abs(hash) % pool.length;
	return pool[idx];
}

function selectSelfRegPhrase(ctx: SelfRegContext, vector: PersonalityVector): string | null {
	if (ctx.recentlySettled) {
		return pick(SELF_REG_PHRASES['settled'], vector, 10);
	}

	if (ctx.sustainedEase) {
		return pick(SELF_REG_PHRASES['at-ease'], vector, 11);
	}

	if (ctx.discomfort > 0.4 && ctx.dominantDimension) {
		const key = `settling-${ctx.dominantDimension}` as keyof typeof SELF_REG_PHRASES;
		if (key in SELF_REG_PHRASES) {
			return pick(SELF_REG_PHRASES[key], vector, 12);
		}
	}

	// Staying-elevated: outside envelope for >1 min but coefficient hasn't escalated
	if (ctx.discomfort > 0.3 && ctx.persistenceMs > 60000 && ctx.coefficient < 1.3) {
		return pick(SELF_REG_PHRASES['staying-elevated'], vector, 13);
	}

	return null;
}

export function interpretVector(
	vector: PersonalityVector,
	mode: string,         // e.g. 'ambient', 'archivist', 'social', 'witness'
	sensor: SensorState,
	sources: string[],    // e.g. ['time:late-night', 'weather:storm']
	selfReg?: SelfRegContext,
): string {
	// 1. Find dominant dimension
	const dims: [Dimension, number][] = [
		['wonder',     vector.wonder],
		['reflection', vector.reflection],
		['mischief',   vector.mischief],
	];
	dims.sort((a, b) => b[1] - a[1]);
	const [dominantDim, dominantVal] = dims[0];
	const dominantTier = getTier(dominantVal);

	// 2. Opening sentence from dominant pool
	const openingPool = PHRASES[dominantDim][dominantTier];
	const opening = pick(openingPool, vector, 0);

	// 3. Secondary color — pick the first non-dominant dim above 'present'
	let secondary: string | null = null;
	for (const [dim, val] of dims.slice(1)) {
		if (val >= 0.25) {
			const secPool = SECONDARY[dim];
			secondary = pick(secPool, vector, 1);
			break;
		}
	}

	// 4. Context

function distance(a: PersonalityVector, b: PersonalityVector): number {
	return Math.sqrt(
		(a.wonder - b.wonder) ** 2 +
		(a.reflection - b.reflection) ** 2 +
		(a.mischief - b.mischief) ** 2,
	);
}