Function bodies 413 total

  private transition(next: SleepState) {
    if (this.state === next) return;
    this.state = next;
    for (const fn of this.listeners) fn(next);
  }

export function parseWeatherResponse(data: Record<string, unknown>): WeatherData | null {
  try {
    const weather = data.weather as { main: string; description: string }[] | undefined;
    const main = data.main as { temp: number; humidity: number; pressure: number } | undefined;
    if (!weather?.length || !main) return null;
    return {
      condition: weather[0].description,
      tempC: main.temp - 273.15,
      humidity: main.humidity,
      pressureHpa: main.pressure,
    };
  } catch {
    return null;
  }
}

export function formatWeatherSummary(weather: WeatherData): string {
  const tempF = Math.round(weather.tempC * 9 / 5 + 32);
  return `${weather.condition}, ${tempF}°F`;
}

export function getSeasonalContext(date: Date = new Date()): string {
  const month = date.getMonth() + 1; // 1-indexed
  for (const [months, desc] of SEASONAL_MAP) {
    if (months.includes(month)) return desc;
  }
  return '';
}

export function startWeatherPolling(
  onUpdate: (weather: WeatherData, summary: string) => void,
  intervalMs = 15 * 60 * 1000, // 15 minutes
): WeatherPoller | null {
  const apiKey = process.env.OPENWEATHER_API_KEY;
  if (!apiKey) return null;

  // Guard against double-invocation: clear any existing timer
  if (pollTimer) {
    clearInterval(pollTimer);
    pollTimer = null;
  }

  // Lafayette, LA coordinates
  const lat = 30.2241;
  const lon = -92.0198;
  const url = `https://api.openweathermap.org/data/2.5/weather?lat=${lat}&lon=${lon}&appid=${apiKey}`;

  const poller: WeatherPoller = { latest: null, stop: () => {} };

  async function poll() {
    try {
      const res = await fetch(url);
      if (!res.ok) return;
      const json = await res.json();
      const weather = parseWeatherResponse(json);
      if (weather) {
        poller.latest = weather;
        onUpdate(weather, formatWeatherSummary(weather));
      }
    } catch {
      // Network errors are non-fatal
    }

  async function poll() {
    try {
      const res = await fetch(url);
      if (!res.ok) return;
      const json = await res.json();
      const weather = parseWeatherResponse(json);
      if (weather) {
        poller.latest = weather;
        onUpdate(weather, formatWeatherSummary(weather));
      }
    } catch {
      // Network errors are non-fatal
    }
  }

export function resolveFaceState(state: FaceResolverState, signals: InteractionSignals): FaceState {
  // P1: Protective
  if (signals.securityStranger) return 'protective';
  // P2: Speaking
  if (signals.voiceSpeaking) return 'speaking';
  // P3: Listening
  if (signals.voiceListening) return 'listening';
  // P4: Sleepy
  if (state.sleepState === 'settling' || state.sleepState === 'asleep') return 'sleepy';
  // P5: Witness
  if (state.mode === 'witness') return 'witness';
  // P6: Thinking
  if (signals.voiceThinking) return 'thinking';
  // P7: Vector-driven (check in order: delighted > mischievous > unamused)
  const v = state.personalityVector;
  if (v.wonder > 0.65) return 'delighted';
  if (v.mischief > 0.55) return 'mischievous';
  if (v.wonder < 0.25 && v.reflection < 0.25 && v.mischief < 0.25) return 'unamused';
  // P8: Fallback
  return 'idle';
}

export function resolveGlowWithOverlay(
  faceState: FaceState,
  thoughtType: string | null,
): { color: string; animation: string; duration: string; overlay?: { color: string; animation: string; duration: string } } {

export function hasEmerged(): boolean {
  return db.select().from(emergenceArtifacts).get() !== undefined;
}

export function getEmergenceArtifact() {
  const rows = db.select().from(emergenceArtifacts).all();
  return rows[0] ?? null;
}

export function getSoulCodeHaiku(): string {
  const artifact = getEmergenceArtifact();
  return artifact?.haikuText ?? 'not yet written';
}

export function getActiveNatalProfile() {
  return db.select().from(natalProfiles).where(eq(natalProfiles.isActive, true)).get() ?? null;
}

export function getNatalSummary(): string {
  const profile = getActiveNatalProfile();
  return profile?.summaryText ?? '';
}

export function getActiveVoiceModel() {
  return db.select().from(voiceModels).where(eq(voiceModels.status, 'active')).get() ?? null;
}

export function getVoiceModelVersion(): string {
  const model = getActiveVoiceModel();
  return model?.versionName ?? 'v0 (pre-training)';
}

export function getAllVoiceModels() {
  return db.select().from(voiceModels).all();
}

export function contentHash(text: string): string {
	return createHash('sha256').update(text).digest('hex');
}

export function chunkBible(markdown: string): BibleChunk[] {
	const headingRegex = /^## (.+)$/gm;
	const headings: { raw: string; id: string; title: string; start: number }[] = [];

	let match;
	while ((match = headingRegex.exec(markdown)) !== null) {
		const raw = match[1];
		const numbered = raw.match(/^(\d+)\.\s+(.+)$/);
		if (numbered) {
			headings.push({ raw, id: numbered[1], title: numbered[2], start: match.index });
		} else {
			const slug = raw.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
			headings.push({ raw, id: slug, title: raw, start: match.index });
		}
	}

	const results: BibleChunk[] = [];

	for (let i = 0; i < headings.length; i++) {
		const heading = headings[i];
		const end = i + 1 < headings.length ? headings[i + 1].start : markdown.length;
		const body = markdown
			.slice(heading.start, end)
			.replace(/^## .+\n+/, '')
			.trim();

		if (!body) continue;

		const chunks = chunkText(body);
		for (let j = 0; j < chunks.length; j++) {
			resul

export function chunkText(text: string): string[] {
	if (text.length <= MAX_CHARS) return [text];

	const paragraphs = text.split(/\n\n+/).filter((p) => p.trim());

	// No paragraph breaks — fall back to sentence/word splitting
	if (paragraphs.length <= 1) {
		return chunkByWords(text);
	}

	const chunks: string[] = [];
	let current = '';

	for (const para of paragraphs) {
		if (current && current.length + para.length + 2 > MAX_CHARS) {
			chunks.push(current.trim());
			current = para;
		} else {
			current = current ? `${current}\n\n${para}` : para;
		}
	}

	if (current.trim()) {
		chunks.push(current.trim());
	}

	return chunks.length ? chunks : [text];
}

function chunkByWords(text: string): string[] {
	if (text.length <= MAX_CHARS) return [text];

	const words = text.split(/\s+/);
	const chunks: string[] = [];
	let current = '';

	for (const word of words) {
		if (current && current.length + word.length + 1 > MAX_CHARS) {
			chunks.push(current.trim());
			current = word;
		} else {
			current = current ? `${current} ${word}` : word;
		}
	}

	if (current.trim()) {
		chunks.push(current.trim());
	}

	return chunks.length ? chunks : [text];
}

export class QueueIndexer {
	private db: BetterSQLite3Database<any>;
	private sqlite: Database.Database;

	constructor(db: BetterSQLite3Database<any>, sqlite: Database.Database) {
		this.db = db;
		this.sqlite = sqlite;
	}

	/**
	 * Upsert a document into the embedding queue.
	 * Chunks long documents, deduplicates by content hash,
	 * and cleans up orphan chunks on re-upsert with fewer chunks.
	 */
	async upsert(doc: MemoryDocument): Promise<{ status: UpsertStatus; chunkCount: number }> {
		const collection = collectionForSource(doc.source);
		const chunks = doc.text.length > MAX_CHARS ? chunkText(doc.text) : [doc.text];
		const metadataJson = JSON.stringify(doc.metadata);

		let overallStatus: UpsertStatus = 'skipped_unchanged';

		for (let i = 0; i < chunks.length; i++) {
			const hash = contentHash(chunks[i]);

			// Check for existing row with same (source, entityId, collection, chunkIndex)
			const existing = this.db
				.select()
				.from(embeddingQueue)
				.where(
					and(
	

	constructor(db: BetterSQLite3Database<any>, sqlite: Database.Database) {
		this.db = db;
		this.sqlite = sqlite;
	}

				and(
					eq(embeddingQueue.source, doc.source),
					eq(embeddingQueue.entityId, doc.entityId),
					eq(embeddingQueue.collection, collection),
					sql`${embeddingQueue.chunkIndex} >= ${chunks.length}`,

	async remove(ref: { source: SourceType; entityId: string }): Promise<void> {
		const collection = collectionForSource(ref.source);
		this.db
			.delete(embeddingQueue)
			.where(
				and(
					eq(embeddingQueue.source, ref.source),
					eq(embeddingQueue.entityId, ref.entityId),
					eq(embeddingQueue.collection, collection),
				),
			)
			.run();
	}

	claimBatch(workerId: string, limit: number): ClaimedRow[] {
		const stmt = this.sqlite.prepare(`
			UPDATE embedding_queue
			SET status = 'processing', locked_by = ?, locked_at = datetime('now'), updated_at = datetime('now')
			WHERE id IN (
				SELECT id FROM embedding_queue
				WHERE status = 'pending' AND (next_attempt_at IS NULL OR next_attempt_at <= datetime('now'))
				ORDER BY created_at, id
				LIMIT ?
			)
			RETURNING
				id, source, entity_id AS entityId, collection, content_hash AS contentHash,
				text, chunk_index AS chunkIndex, metadata, embedding_model AS embeddingModel,
				chunker_version AS chunkerVersion, status, retry_count AS retryCount,
				last_error AS lastError, locked_at AS lockedAt, locked_by AS lockedBy,
				next_attempt_at AS nextAttemptAt, created_at AS createdAt,
				processed_at AS processedAt, updated_at AS updatedAt
		`);
		return stmt.all(workerId, limit) as ClaimedRow[];
	}

	markIndexed(id: number, workerId: string, claimedHash: string): boolean {
		const result = this.sqlite.prepare(`
			UPDATE embedding_queue
			SET status = 'indexed', processed_at = datetime('now'), updated_at = datetime('now')
			WHERE id = ? AND locked_by = ? AND content_hash = ?
		`).run(id, workerId, claimedHash);

		if (result.changes === 0) {
			// Hash changed during processing — reset to pending
			this.sqlite.prepare(`
				UPDATE embedding_queue
				SET status = 'pending', locked_by = NULL, locked_at = NULL, updated_at = datetime('now')
				WHERE id = ? AND locked_by = ?
			`).run(id, workerId);
			return false;
		}
		return true;
	}

	markFailed(id: number, error: string): void {
		const row = this.db
			.select({ retryCount: embeddingQueue.retryCount })
			.from(embeddingQueue)
			.where(eq(embeddingQueue.id, id))
			.get();

		if (!row) return;

		const newRetryCount = row.retryCount + 1;

		if (newRetryCount >= MAX_RETRY_COUNT) {
			// Permanent failure
			this.db
				.update(embeddingQueue)
				.set({
					status: 'failed',
					retryCount: newRetryCount,
					lastError: error,
					lockedAt: null,
					lockedBy: null,
					updatedAt: sql`datetime('now')`,
				})
				.where(eq(embeddingQueue.id, id))
				.run();
		} else {
			// Exponential backoff: 2^retryCount seconds (2, 4, 8, 16...)
			const backoffSeconds = Math.pow(2, newRetryCount);
			this.db
				.update(embeddingQueue)
				.set({
					status: 'pending',
					retryCount: newRetryCount,
					lastError: error,
					lockedAt: null,
					lockedBy: null,
					nextAttemptAt: sql`datetime('now', '+${sql.raw(String(backoffSeconds))} seconds')`,
					updatedAt: 

	recoverStuckJobs(thresholdMs: number): number {
		const thresholdSeconds = Math.floor(thresholdMs / 1000);
		const result = this.sqlite.prepare(`
			UPDATE embedding_queue
			SET status = 'pending', locked_by = NULL, locked_at = NULL, updated_at = datetime('now')
			WHERE status = 'processing'
			  AND locked_at IS NOT NULL
			  AND locked_at <= datetime('now', '-${thresholdSeconds} seconds')
		`).run();
		return result.changes;
	}

	getQueueStats(): QueueStats {
		const rows = this.sqlite.prepare(`
			SELECT status, COUNT(*) as count FROM embedding_queue GROUP BY status
		`).all() as { status: string; count: number }[];

		const stats: QueueStats = { pending: 0, processing: 0, indexed: 0, failed: 0 };
		for (const row of rows) {
			if (row.status in stats) {
				stats[row.status as keyof QueueStats] = row.count;
			}
		}
		return stats;
	}

export function registerMemoryProvider(provider: MemoryProvider) {
	_provider = provider;
}

export function getMemoryProvider(): MemoryProvider | null {
	return _provider;
}

export function enqueueMemory(
	source: SourceType,
	entityId: string | number,
	text: string,
	metadata: Record<string, string | number> = {},
) {
	const provider = _provider;
	if (!provider) return;
	provider
		.upsert({
			source,
			entityId: String(entityId),
			text,
			metadata: { ...metadata, createdAt: new Date().toISOString() },
		})
		.catch(() => {}); // fire-and-forget
}

export function removeMemory(source: SourceType, entityId: string | number) {
	const provider = _provider;
	if (!provider) return;
	provider.remove({ source, entityId: String(entityId) }).catch(() => {});
}

export class MemoryProvider implements MemoryRetriever, MemoryIndexer, MemoryOps {
	private indexer: QueueIndexer;
	private retriever: MemoryRetrieverImpl;
	private chroma: ChromaClient;
	private ollamaUrl: string;
	private sqlite: Database.Database;

	constructor(opts: { chromaUrl: string; ollamaUrl: string }) {
		this.chroma = new ChromaClient({ path: opts.chromaUrl });
		this.ollamaUrl = opts.ollamaUrl;
		this.sqlite = sqlite;
		this.indexer = new QueueIndexer(db, sqlite);
		this.retriever = new MemoryRetrieverImpl(this.chroma as any, this.ollamaUrl);
	}

	// --- MemoryRetriever ---

	async retrieve(query: string, ctx: RetrieveContext): Promise<RetrieveResult> {
		return this.retriever.retrieve(query, ctx);
	}

	// --- MemoryIndexer ---

	async upsert(doc: MemoryDocument): Promise<{ status: UpsertStatus; chunkCount: number }> {
		return this.indexer.upsert(doc);
	}

	async remove(ref: { source: SourceType; entityId: string }): Promise<void> {
		// Remove from ChromaDB FIRST — if thi

	constructor(opts: { chromaUrl: string; ollamaUrl: string }) {
		this.chroma = new ChromaClient({ path: opts.chromaUrl });
		this.ollamaUrl = opts.ollamaUrl;
		this.sqlite = sqlite;
		this.indexer = new QueueIndexer(db, sqlite);
		this.retriever = new MemoryRetrieverImpl(this.chroma as any, this.ollamaUrl);
	}

	async retrieve(query: string, ctx: RetrieveContext): Promise<RetrieveResult> {
		return this.retriever.retrieve(query, ctx);
	}

	async remove(ref: { source: SourceType; entityId: string }): Promise<void> {
		// Remove from ChromaDB FIRST — if this fails, queue entries remain and
		// startup reconciliation will retry the delete (orphan cleanup)
		try {
			const collectionName = collectionForSource(ref.source);
			const collection = await this.chroma.getOrCreateCollection({ name: collectionName });
			const prefix = `${ref.source}:${ref.entityId}:`;
			const results = await collection.get({
				where: { source: ref.source as string },
			});
			const matchingIds = (results.ids ?? []).filter((id: string) => id.startsWith(prefix));
			if (matchingIds.length > 0) {
				await collection.delete({ ids: matchingIds });
			}
		} catch {
			// Fail-open: ChromaDB unreachable — queue entries stay, reconciliation cleans up
		}

		// Remove from queue — always succeeds (local SQLite)
		await this.indexer.remove(ref);
	}

	async health(): Promise<MemoryHealth> {
		// ChromaDB heartbeat
		let chromaStatus: 'ok' | 'unreachable' = 'unreachable';
		try {
			await this.chroma.heartbeat();
			chromaStatus = 'ok';
		} catch {
			// unreachable
		}

		// Ollama tags endpoint
		let ollamaStatus: 'ok' | 'unreachable' = 'unreachable';
		try {
			const res = await fetch(`${this.ollamaUrl}/api/tags`);
			if (res.ok) ollamaStatus = 'ok';
		} catch {
			// unreachable
		}

		// Queue stats
		const queue = this.indexer.getQueueStats();

		// Collection counts
		const collections: { name: string; count: number }[] = [];
		for (const name of COLLECTION_NAMES) {
			try {
				const coll = await this.chroma.getOrCreateCollection({ name });
				const count = await coll.count();
				collections.push({ name, count });
			} catch {
				collections.push({ name, count: 0 });
			}
		}

		return {
			chroma: chromaStatus,
			ollama: ollamaStatus,
			queue,
			collections,
		};
	}

	async processBatch(limit = 5): Promise<BatchStats> {
		const claimed = this.indexer.claimBatch(WORKER_ID, limit);
		let processed = 0;
		let failed = 0;

		for (const row of claimed) {
			try {
				// 1. Embed text via Ollama
				const embedRes = await fetch(`${this.ollamaUrl}/api/embed`, {
					method: 'POST',
					headers: { 'Content-Type': 'application/json' },
					body: JSON.stringify({ model: EMBEDDING_MODEL, input: row.text }),
				});

				if (!embedRes.ok) {
					throw new Error(`Ollama embed failed: ${embedRes.status}`);
				}

				const embedData = (await embedRes.json()) as { embeddings: number[][] };
				const embedding = embedData.embeddings[0];

				// 2. Upsert to ChromaDB
				const chromaDocId = `${row.source}:${row.entityId}:${row.chunkIndex}`;
				const collection = await this.chroma.getOrCreateCollection({ name: row.collection });

				const meta = JSON.parse(row.metadata);
				await collection.upsert({
					ids: [chromaDocId],
					embeddings: [embedding],
					do

	async ensureCollections(): Promise<void> {
		for (const name of COLLECTION_NAMES) {
			await this.chroma.getOrCreateCollection({ name });
		}
		console.log('[memory] Ensured all 3 collections exist');
	}

	async indexBible(): Promise<void> {
		const biblePath = join(process.cwd(), '..', 'docs', 'bible', 'beaus-bible.md');

		let content: string;
		try {
			content = fs.readFileSync(biblePath, 'utf8') as string;
		} catch {
			console.warn(`[memory] Bible not found at ${biblePath} — skipping indexBible`);
			return;
		}

		const chunks = chunkBible(content);
		const now = new Date().toISOString();

		for (const chunk of chunks) {
			await this.upsert({
				source: 'canon',
				entityId: `bible-${chunk.sectionId}-${chunk.chunkIndex}`,
				text: chunk.text,
				metadata: {
					sectionId: chunk.sectionId,
					title: chunk.title,
					createdAt: now,
				},
			});
		}

		console.log(`[memory] Indexed bible: ${chunks.length} chunks queued`);
	}

	async reconcileAll(): Promise<void> {
		const recovered = this.indexer.recoverStuckJobs(STUCK_JOB_THRESHOLD_MS);
		if (recovered > 0) {
			console.log(`[memory] Recovered ${recovered} stuck jobs`);
		}
	}

	recoverStuckJobs(): number {
		return this.indexer.recoverStuckJobs(STUCK_JOB_THRESHOLD_MS);
	}

export class MemoryRetrieverImpl implements MemoryRetriever {
	constructor(
		private chromaClient: ChromaClient,
		private ollamaUrl: string,
	) {}

	async retrieve(query: string, ctx: RetrieveContext): Promise<RetrieveResult> {
		const empty: RetrieveResult = { fragments: [], usedTokens: 0, provenance: [] };

		// 1. Get collection policy for this mode + caller
		const policy = getCollectionPolicy(ctx.mode, ctx.caller);
		const maxTokens = ctx.maxTokens ? Math.min(ctx.maxTokens, policy.maxTokens) : policy.maxTokens;

		// 2. Embed the query text via Ollama
		let embedding: number[];
		try {
			embedding = await this.embedQuery(query);
		} catch {
			// Fail-open: if Ollama is unreachable, return empty
			return empty;
		}

		// 3. Query each allowed collection in parallel (with timeout)
		const rawFragments = await this.queryCollections(policy.collections, embedding, ctx);

		// 4. Deduplicate by (source, entityId) — keep highest-scoring
		const deduped = this.deduplicate(rawFragment

	constructor(
		private chromaClient: ChromaClient,
		private ollamaUrl: string,
	) {}

	async retrieve(query: string, ctx: RetrieveContext): Promise<RetrieveResult> {
		const empty: RetrieveResult = { fragments: [], usedTokens: 0, provenance: [] };

		// 1. Get collection policy for this mode + caller
		const policy = getCollectionPolicy(ctx.mode, ctx.caller);
		const maxTokens = ctx.maxTokens ? Math.min(ctx.maxTokens, policy.maxTokens) : policy.maxTokens;

		// 2. Embed the query text via Ollama
		let embedding: number[];
		try {
			embedding = await this.embedQuery(query);
		} catch {
			// Fail-open: if Ollama is unreachable, return empty
			return empty;
		}

		// 3. Query each allowed collection in parallel (with timeout)
		const rawFragments = await this.queryCollections(policy.collections, embedding, ctx);

		// 4. Deduplicate by (source, entityId) — keep highest-scoring
		const deduped = this.deduplicate(rawFragments);

		// 5. Rerank
		const ranked = this.rerank(deduped);

		// 6. Trim to token budget
		const trimmed = this.trimToBudget(ranked, maxTokens);

		//

	private async embedQuery(query: string): Promise<number[]> {
		const controller = new AbortController();
		const timeout = setTimeout(() => controller.abort(), RETRIEVAL_TIMEOUT_MS);

		try {
			const res = await fetch(`${this.ollamaUrl}/api/embed`, {
				method: 'POST',
				headers: { 'Content-Type': 'application/json' },
				body: JSON.stringify({ model: EMBEDDING_MODEL, input: query }),
				signal: controller.signal,
			});

			if (!res.ok) {
				throw new Error(`Ollama embed failed: ${res.status}`);
			}

			const data = (await res.json()) as { embeddings: number[][] };
			return data.embeddings[0];
		} finally {
			clearTimeout(timeout);
		}
	}

	private async queryCollections(
		collections: CollectionName[],
		embedding: number[],
		ctx: RetrieveContext,
	): Promise<MemoryFragment[]> {
		const results = await Promise.allSettled(
			collections.map((name) => this.queryOneCollection(name, embedding, ctx)),
		);

		const fragments: MemoryFragment[] = [];
		for (const result of results) {
			if (result.status === 'fulfilled') {
				fragments.push(...result.value);
			}
			// Partial failure: rejected collections are silently skipped
		}
		return fragments;
	}

	private async queryOneCollection(
		collectionName: CollectionName,
		embedding: number[],
		ctx: RetrieveContext,
	): Promise<MemoryFragment[]> {
		const controller = new AbortController();
		const timeout = setTimeout(() => controller.abort(), RETRIEVAL_TIMEOUT_MS);

		try {
			const collection = await this.chromaClient.getCollection({ name: collectionName });

			const queryResult = await collection.query({
				queryEmbeddings: [embedding],
				nResults: RESULTS_PER_COLLECTION,
			});

			const fragments: MemoryFragment[] = [];

			// QueryResult has nested arrays: ids[queryIdx][resultIdx]
			const ids = queryResult.ids[0] ?? [];
			const documents = queryResult.documents[0] ?? [];
			const metadatas = queryResult.metadatas[0] ?? [];
			const distances = queryResult.distances[0] ?? [];

			for (let i = 0; i < ids.length; i++) {
				const text = documents[i];
				if (!text) continue;

				const meta = (metadatas[i] ?? {}) as Record<string, string | number>;
				const source = (meta.

	private deduplicate(fragments: MemoryFragment[]): MemoryFragment[] {
		const best = new Map<string, MemoryFragment>();

		for (const frag of fragments) {
			const key = `${frag.source}::${frag.entityId}`;
			const existing = best.get(key);
			if (!existing || frag.rawDistance < existing.rawDistance) {
				best.set(key, frag);
			}
		}

		return Array.from(best.values());
	}