@gencode/agents 0.0.4 → 0.0.6

package/dist/manager-qXa-NP0p.js

@@ -1,1651 +0,0 @@
-import { createRequire } from "node:module";
-import fs from "node:fs/promises";
-import path from "node:path";
-import crypto, { randomUUID } from "node:crypto";
-import fsSync from "node:fs";
-
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-//#region src/session/session.ts
-/** Resolves the sessions directory path within a data directory */
-function sessionsDir(dataDir) {
-	return path.join(dataDir, ".pingclaw", "sessions");
-}
-/** Resolves the directory for a specific session */
-function sessionDir(dataDir, sessionId) {
-	return path.join(sessionsDir(dataDir), sessionId);
-}
-/** Resolves the transcript file path for a session */
-function transcriptPath(dataDir, sessionId) {
-	return path.join(sessionDir(dataDir, sessionId), "transcript.jsonl");
-}
-/** Resolves the metadata file path for a session */
-function metadataPath(dataDir, sessionId) {
-	return path.join(sessionDir(dataDir, sessionId), "session.json");
-}
-/** Creates a new session with a generated ID */
-async function createSession(dataDir, channel) {
-	const sessionId = randomUUID();
-	const dir = sessionDir(dataDir, sessionId);
-	await fs.mkdir(dir, { recursive: true });
-	const channelPath = path.join(dir, ".channel");
-	await fs.writeFile(channelPath, channel, "utf-8");
-	return sessionId;
-}
-/** Ensures a session directory exists (for resuming an existing session) */
-async function ensureSession(dataDir, sessionId) {
-	const dir = sessionDir(dataDir, sessionId);
-	await fs.mkdir(dir, { recursive: true });
-}
-/** Loads all transcript entries from a session */
-async function loadTranscript(dataDir, sessionId) {
-	const filePath = transcriptPath(dataDir, sessionId);
-	let content;
-	try {
-		content = await fs.readFile(filePath, "utf-8");
-	} catch (err) {
-		if (err.code === "ENOENT") return [];
-		throw err;
-	}
-	const entries = [];
-	for (const line of content.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			entries.push(JSON.parse(trimmed));
-		} catch {}
-	}
-	return entries;
-}
-/** Appends a single entry to the transcript file */
-async function appendTranscriptEntry(dataDir, sessionId, entry) {
-	await ensureSession(dataDir, sessionId);
-	const filePath = transcriptPath(dataDir, sessionId);
-	const line = JSON.stringify(entry) + "\n";
-	await fs.appendFile(filePath, line, "utf-8");
-	try {
-		const { MemoryIndexManager } = await Promise.resolve().then(() => manager_exports);
-		MemoryIndexManager.get(dataDir).noteSessionUpdate(filePath);
-	} catch {}
-}
-/** Lists all session IDs within a data directory */
-async function listSessions(dataDir) {
-	const dir = sessionsDir(dataDir);
-	try {
-		return (await fs.readdir(dir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
-	} catch (err) {
-		if (err.code === "ENOENT") return [];
-		throw err;
-	}
-}
-/** Saves session metadata to disk */
-async function saveSessionMetadata(dataDir, metadata) {
-	await ensureSession(dataDir, metadata.id);
-	const filePath = metadataPath(dataDir, metadata.id);
-	await fs.writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
-}
-/** Loads session metadata from disk; returns null if not found */
-async function loadSessionMetadata(dataDir, sessionId) {
-	const filePath = metadataPath(dataDir, sessionId);
-	try {
-		const content = await fs.readFile(filePath, "utf-8");
-		const meta = JSON.parse(content);
-		if (!meta.channel) {
-			const channelPath = path.join(sessionDir(dataDir, sessionId), ".channel");
-			try {
-				meta.channel = (await fs.readFile(channelPath, "utf-8")).trim();
-			} catch {
-				meta.channel = "WEB";
-			}
-		}
-		return meta;
-	} catch (err) {
-		if (err.code === "ENOENT") return null;
-		throw err;
-	}
-}
-/** Lists all sessions with their metadata summaries, optionally filtered by channel */
-async function listSessionSummaries(dataDir, channel) {
-	const ids = await listSessions(dataDir);
-	const summaries = await Promise.all(ids.map(async (id) => {
-		const meta = await loadSessionMetadata(dataDir, id);
-		return {
-			id,
-			title: meta?.title ?? id,
-			channel: meta?.channel ?? "WEB",
-			createdAt: meta?.createdAt ?? "",
-			updatedAt: meta?.updatedAt ?? ""
-		};
-	}));
-	return channel ? summaries.filter((s) => s.channel === channel) : summaries;
-}
-
-//#endregion
-//#region src/memory/embeddings.ts
-const DEFAULT_DIMENSIONS = 384;
-function tokenize$1(text) {
-	return (text.toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? []).filter(Boolean);
-}
-function hashToken(token) {
-	return crypto.createHash("sha256").update(token).digest().readUInt32BE(0);
-}
-function buildEmbedding(text, dims = DEFAULT_DIMENSIONS) {
-	const vec = new Array(dims).fill(0);
-	const tokens = tokenize$1(text);
-	if (tokens.length === 0) return vec;
-	for (const token of tokens) {
-		const idx = hashToken(token) % dims;
-		vec[idx] += 1;
-	}
-	const norm = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
-	if (norm > 0) for (let i = 0; i < vec.length; i += 1) vec[i] = vec[i] / norm;
-	return vec;
-}
-function createMockEmbeddingProvider(params) {
-	const model = params?.model?.trim() || "mock-embedding-v1";
-	const dimensions = params?.dimensions ?? DEFAULT_DIMENSIONS;
-	return {
-		id: "external-mock",
-		model,
-		embedQuery: async (text) => buildEmbedding(text, dimensions),
-		embedBatch: async (texts) => texts.map((text) => buildEmbedding(text, dimensions))
-	};
-}
-
-//#endregion
-//#region src/memory/fs-utils.ts
-function isFileMissingError(err) {
-	return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
-}
-async function statRegularFile(absPath) {
-	let stat;
-	try {
-		stat = await fs.lstat(absPath);
-	} catch (err) {
-		if (isFileMissingError(err)) return { missing: true };
-		throw err;
-	}
-	if (stat.isSymbolicLink() || !stat.isFile()) throw new Error("path required");
-	return {
-		missing: false,
-		stat
-	};
-}
-
-//#endregion
-//#region src/memory/internal.ts
-function ensureDir(dir) {
-	try {
-		fsSync.mkdirSync(dir, { recursive: true });
-	} catch {}
-	return dir;
-}
-function normalizeRelPath(value) {
-	return value.trim().replace(/^[./]+/, "").replace(/\\/g, "/");
-}
-function isMemoryPath(relPath) {
-	const normalized = normalizeRelPath(relPath);
-	if (!normalized) return false;
-	if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
-	return normalized.startsWith("memory/");
-}
-async function walkDir(dir, files) {
-	const entries = await fs.readdir(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const full = path.join(dir, entry.name);
-		if (entry.isSymbolicLink()) continue;
-		if (entry.isDirectory()) {
-			await walkDir(full, files);
-			continue;
-		}
-		if (!entry.isFile()) continue;
-		if (!entry.name.endsWith(".md")) continue;
-		files.push(full);
-	}
-}
-async function listMemoryFiles(memoryRoot) {
-	const result = [];
-	const memoryFile = path.join(memoryRoot, "MEMORY.md");
-	const altMemoryFile = path.join(memoryRoot, "memory.md");
-	const memoryDir = path.join(memoryRoot, "memory");
-	const addMarkdownFile = async (absPath) => {
-		try {
-			const stat = await fs.lstat(absPath);
-			if (stat.isSymbolicLink() || !stat.isFile()) return;
-			if (!absPath.endsWith(".md")) return;
-			result.push(absPath);
-		} catch {}
-	};
-	await addMarkdownFile(memoryFile);
-	await addMarkdownFile(altMemoryFile);
-	try {
-		const dirStat = await fs.lstat(memoryDir);
-		if (!dirStat.isSymbolicLink() && dirStat.isDirectory()) await walkDir(memoryDir, result);
-	} catch {}
-	if (result.length <= 1) return result;
-	const seen = /* @__PURE__ */ new Set();
-	const deduped = [];
-	for (const entry of result) {
-		let key = entry;
-		try {
-			key = await fs.realpath(entry);
-		} catch {}
-		if (seen.has(key)) continue;
-		seen.add(key);
-		deduped.push(entry);
-	}
-	return deduped;
-}
-function hashText(value) {
-	return crypto.createHash("sha256").update(value).digest("hex");
-}
-async function buildFileEntry(absPath, memoryRoot) {
-	let stat;
-	try {
-		stat = await fs.stat(absPath);
-	} catch (err) {
-		if (isFileMissingError(err)) return null;
-		throw err;
-	}
-	let content;
-	try {
-		content = await fs.readFile(absPath, "utf-8");
-	} catch (err) {
-		if (isFileMissingError(err)) return null;
-		throw err;
-	}
-	const hash = hashText(content);
-	return {
-		path: path.relative(memoryRoot, absPath).replace(/\\/g, "/"),
-		absPath,
-		mtimeMs: stat.mtimeMs,
-		size: stat.size,
-		hash
-	};
-}
-function chunkMarkdown(content, chunking) {
-	const lines = content.split("\n");
-	if (lines.length === 0) return [];
-	const maxChars = Math.max(32, chunking.tokens * 4);
-	const overlapChars = Math.max(0, chunking.overlap * 4);
-	const chunks = [];
-	let current = [];
-	let currentChars = 0;
-	const flush = () => {
-		if (current.length === 0) return;
-		const firstEntry = current[0];
-		const lastEntry = current[current.length - 1];
-		if (!firstEntry || !lastEntry) return;
-		const text = current.map((entry) => entry.line).join("\n");
-		const startLine = firstEntry.lineNo;
-		const endLine = lastEntry.lineNo;
-		chunks.push({
-			startLine,
-			endLine,
-			text,
-			hash: hashText(text)
-		});
-	};
-	const carryOverlap = () => {
-		if (overlapChars <= 0 || current.length === 0) {
-			current = [];
-			currentChars = 0;
-			return;
-		}
-		let acc = 0;
-		const kept = [];
-		for (let i = current.length - 1; i >= 0; i -= 1) {
-			const entry = current[i];
-			if (!entry) continue;
-			acc += entry.line.length + 1;
-			kept.unshift(entry);
-			if (acc >= overlapChars) break;
-		}
-		current = kept;
-		currentChars = kept.reduce((sum, entry) => sum + entry.line.length + 1, 0);
-	};
-	for (let i = 0; i < lines.length; i += 1) {
-		const line = lines[i] ?? "";
-		const lineNo = i + 1;
-		const segments = [];
-		if (line.length === 0) segments.push("");
-		else for (let start = 0; start < line.length; start += maxChars) segments.push(line.slice(start, start + maxChars));
-		for (const segment of segments) {
-			const lineSize = segment.length + 1;
-			if (currentChars + lineSize > maxChars && current.length > 0) {
-				flush();
-				carryOverlap();
-			}
-			current.push({
-				line: segment,
-				lineNo
-			});
-			currentChars += lineSize;
-		}
-	}
-	flush();
-	return chunks;
-}
-function remapChunkLines(chunks, lineMap) {
-	if (!lineMap || lineMap.length === 0) return;
-	for (const chunk of chunks) {
-		chunk.startLine = lineMap[chunk.startLine - 1] ?? chunk.startLine;
-		chunk.endLine = lineMap[chunk.endLine - 1] ?? chunk.endLine;
-	}
-}
-function parseEmbedding(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		return Array.isArray(parsed) ? parsed : [];
-	} catch {
-		return [];
-	}
-}
-function cosineSimilarity(a, b) {
-	if (a.length === 0 || b.length === 0) return 0;
-	const len = Math.min(a.length, b.length);
-	let dot = 0;
-	let normA = 0;
-	let normB = 0;
-	for (let i = 0; i < len; i += 1) {
-		const av = a[i] ?? 0;
-		const bv = b[i] ?? 0;
-		dot += av * bv;
-		normA += av * av;
-		normB += bv * bv;
-	}
-	if (normA === 0 || normB === 0) return 0;
-	return dot / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-
-//#endregion
-//#region src/memory/mmr.ts
-const DEFAULT_MMR_CONFIG = {
-	enabled: false,
-	lambda: .7
-};
-function tokenize(text) {
-	const tokens = text.toLowerCase().match(/[a-z0-9_]+/g) ?? [];
-	return new Set(tokens);
-}
-function jaccardSimilarity(setA, setB) {
-	if (setA.size === 0 && setB.size === 0) return 1;
-	if (setA.size === 0 || setB.size === 0) return 0;
-	let intersectionSize = 0;
-	const smaller = setA.size <= setB.size ? setA : setB;
-	const larger = setA.size <= setB.size ? setB : setA;
-	for (const token of smaller) if (larger.has(token)) intersectionSize++;
-	const unionSize = setA.size + setB.size - intersectionSize;
-	return unionSize === 0 ? 0 : intersectionSize / unionSize;
-}
-function maxSimilarityToSelected(item, selectedItems, tokenCache) {
-	if (selectedItems.length === 0) return 0;
-	let maxSim = 0;
-	const itemTokens = tokenCache.get(item.id) ?? tokenize(item.content);
-	for (const selected of selectedItems) {
-		const sim = jaccardSimilarity(itemTokens, tokenCache.get(selected.id) ?? tokenize(selected.content));
-		if (sim > maxSim) maxSim = sim;
-	}
-	return maxSim;
-}
-function computeMMRScore(relevance, maxSimilarity, lambda) {
-	return lambda * relevance - (1 - lambda) * maxSimilarity;
-}
-function mmrRerank(items, config = {}) {
-	const { enabled = DEFAULT_MMR_CONFIG.enabled, lambda = DEFAULT_MMR_CONFIG.lambda } = config;
-	if (!enabled || items.length <= 1) return [...items];
-	const clampedLambda = Math.max(0, Math.min(1, lambda));
-	if (clampedLambda === 1) return items.slice().sort((a, b) => b.score - a.score);
-	const tokenCache = /* @__PURE__ */ new Map();
-	for (const item of items) tokenCache.set(item.id, tokenize(item.content));
-	const maxScore = Math.max(...items.map((i) => i.score));
-	const minScore = Math.min(...items.map((i) => i.score));
-	const scoreRange = maxScore - minScore;
-	const normalizeScore = (score) => {
-		if (scoreRange === 0) return 1;
-		return (score - minScore) / scoreRange;
-	};
-	const selected = [];
-	const remaining = new Set(items);
-	while (remaining.size > 0) {
-		let bestItem = null;
-		let bestMMRScore = -Infinity;
-		for (const candidate of remaining) {
-			const mmrScore = computeMMRScore(normalizeScore(candidate.score), maxSimilarityToSelected(candidate, selected, tokenCache), clampedLambda);
-			if (mmrScore > bestMMRScore || mmrScore === bestMMRScore && candidate.score > (bestItem?.score ?? -Infinity)) {
-				bestMMRScore = mmrScore;
-				bestItem = candidate;
-			}
-		}
-		if (bestItem) {
-			selected.push(bestItem);
-			remaining.delete(bestItem);
-		} else break;
-	}
-	return selected;
-}
-function applyMMRToHybridResults(results, config = {}) {
-	if (results.length === 0) return results;
-	const itemById = /* @__PURE__ */ new Map();
-	return mmrRerank(results.map((r, index) => {
-		const id = `${r.path}:${r.startLine}:${index}`;
-		itemById.set(id, r);
-		return {
-			id,
-			score: r.score,
-			content: r.snippet
-		};
-	}), config).map((item) => itemById.get(item.id));
-}
-
-//#endregion
-//#region src/memory/temporal-decay.ts
-const DEFAULT_TEMPORAL_DECAY_CONFIG = {
-	enabled: false,
-	halfLifeDays: 30
-};
-const DAY_MS = 1440 * 60 * 1e3;
-const DATED_MEMORY_PATH_RE = /(?:^|\/)(?:memory)\/(\d{4})-(\d{2})-(\d{2})\.md$/;
-function toDecayLambda(halfLifeDays) {
-	if (!Number.isFinite(halfLifeDays) || halfLifeDays <= 0) return 0;
-	return Math.LN2 / halfLifeDays;
-}
-function calculateTemporalDecayMultiplier(params) {
-	const lambda = toDecayLambda(params.halfLifeDays);
-	const clampedAge = Math.max(0, params.ageInDays);
-	if (lambda <= 0 || !Number.isFinite(clampedAge)) return 1;
-	return Math.exp(-lambda * clampedAge);
-}
-function applyTemporalDecayToScore(params) {
-	return params.score * calculateTemporalDecayMultiplier(params);
-}
-function parseMemoryDateFromPath(filePath) {
-	const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "");
-	const match = DATED_MEMORY_PATH_RE.exec(normalized);
-	if (!match) return null;
-	const year = Number(match[1]);
-	const month = Number(match[2]);
-	const day = Number(match[3]);
-	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) return null;
-	const timestamp = Date.UTC(year, month - 1, day);
-	const parsed = new Date(timestamp);
-	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) return null;
-	return parsed;
-}
-function isEvergreenMemoryPath(filePath) {
-	const normalized = filePath.replaceAll("\\", "/").replace(/^\.\//, "");
-	if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
-	if (!normalized.startsWith("memory/")) return false;
-	return !DATED_MEMORY_PATH_RE.test(normalized);
-}
-async function extractTimestamp(params) {
-	const fromPath = parseMemoryDateFromPath(params.filePath);
-	if (fromPath) return fromPath;
-	if (params.source === "memory" && isEvergreenMemoryPath(params.filePath)) return null;
-	if (!params.memoryRoot) return null;
-	const absolutePath = path.isAbsolute(params.filePath) ? params.filePath : path.resolve(params.memoryRoot, params.filePath);
-	try {
-		const stat = await fs.stat(absolutePath);
-		if (!Number.isFinite(stat.mtimeMs)) return null;
-		return new Date(stat.mtimeMs);
-	} catch {
-		return null;
-	}
-}
-function ageInDaysFromTimestamp(timestamp, nowMs) {
-	return Math.max(0, nowMs - timestamp.getTime()) / DAY_MS;
-}
-async function applyTemporalDecayToHybridResults(params) {
-	const config = {
-		...DEFAULT_TEMPORAL_DECAY_CONFIG,
-		...params.temporalDecay
-	};
-	if (!config.enabled) return [...params.results];
-	const nowMs = params.nowMs ?? Date.now();
-	const timestampPromiseCache = /* @__PURE__ */ new Map();
-	return Promise.all(params.results.map(async (entry) => {
-		const cacheKey = `${entry.source}:${entry.path}`;
-		let timestampPromise = timestampPromiseCache.get(cacheKey);
-		if (!timestampPromise) {
-			timestampPromise = extractTimestamp({
-				filePath: entry.path,
-				source: entry.source,
-				memoryRoot: params.memoryRoot
-			});
-			timestampPromiseCache.set(cacheKey, timestampPromise);
-		}
-		const timestamp = await timestampPromise;
-		if (!timestamp) return entry;
-		const decayedScore = applyTemporalDecayToScore({
-			score: entry.score,
-			ageInDays: ageInDaysFromTimestamp(timestamp, nowMs),
-			halfLifeDays: config.halfLifeDays
-		});
-		return {
-			...entry,
-			score: decayedScore
-		};
-	}));
-}
-
-//#endregion
-//#region src/memory/hybrid.ts
-function buildFtsQuery(raw) {
-	const tokens = raw.match(/[\p{L}\p{N}_]+/gu)?.map((t) => t.trim()).filter(Boolean) ?? [];
-	if (tokens.length === 0) return null;
-	return tokens.map((t) => `"${t.replaceAll("\"", "")}"`).join(" AND ");
-}
-function bm25RankToScore(rank) {
-	return 1 / (1 + (Number.isFinite(rank) ? Math.max(0, rank) : 999));
-}
-async function mergeHybridResults(params) {
-	const byId = /* @__PURE__ */ new Map();
-	for (const r of params.vector) byId.set(r.id, {
-		id: r.id,
-		path: r.path,
-		startLine: r.startLine,
-		endLine: r.endLine,
-		source: r.source,
-		snippet: r.snippet,
-		vectorScore: r.vectorScore,
-		textScore: 0
-	});
-	for (const r of params.keyword) {
-		const existing = byId.get(r.id);
-		if (existing) {
-			existing.textScore = r.textScore;
-			if (r.snippet && r.snippet.length > 0) existing.snippet = r.snippet;
-		} else byId.set(r.id, {
-			id: r.id,
-			path: r.path,
-			startLine: r.startLine,
-			endLine: r.endLine,
-			source: r.source,
-			snippet: r.snippet,
-			vectorScore: 0,
-			textScore: r.textScore
-		});
-	}
-	const sorted = (await applyTemporalDecayToHybridResults({
-		results: Array.from(byId.values()).map((entry) => {
-			const score = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
-			return {
-				path: entry.path,
-				startLine: entry.startLine,
-				endLine: entry.endLine,
-				score,
-				snippet: entry.snippet,
-				source: entry.source
-			};
-		}),
-		temporalDecay: {
-			...DEFAULT_TEMPORAL_DECAY_CONFIG,
-			...params.temporalDecay
-		},
-		memoryRoot: params.memoryRoot,
-		nowMs: params.nowMs
-	})).slice().sort((a, b) => b.score - a.score);
-	const mmrConfig = {
-		...DEFAULT_MMR_CONFIG,
-		...params.mmr
-	};
-	if (mmrConfig.enabled) return applyMMRToHybridResults(sorted, mmrConfig);
-	return sorted;
-}
-
-//#endregion
-//#region src/memory/memory-schema.ts
-function ensureMemoryIndexSchema(params) {
-	params.db.exec(`
-    CREATE TABLE IF NOT EXISTS meta (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `);
-	params.db.exec(`
-    CREATE TABLE IF NOT EXISTS files (
-      path TEXT PRIMARY KEY,
-      source TEXT NOT NULL DEFAULT 'memory',
-      hash TEXT NOT NULL,
-      mtime INTEGER NOT NULL,
-      size INTEGER NOT NULL
-    );
-  `);
-	params.db.exec(`
-    CREATE TABLE IF NOT EXISTS chunks (
-      id TEXT PRIMARY KEY,
-      path TEXT NOT NULL,
-      source TEXT NOT NULL DEFAULT 'memory',
-      start_line INTEGER NOT NULL,
-      end_line INTEGER NOT NULL,
-      hash TEXT NOT NULL,
-      model TEXT NOT NULL,
-      text TEXT NOT NULL,
-      embedding TEXT NOT NULL,
-      updated_at INTEGER NOT NULL
-    );
-  `);
-	params.db.exec(`
-    CREATE TABLE IF NOT EXISTS ${params.embeddingCacheTable} (
-      provider TEXT NOT NULL,
-      model TEXT NOT NULL,
-      provider_key TEXT NOT NULL,
-      hash TEXT NOT NULL,
-      embedding TEXT NOT NULL,
-      dims INTEGER,
-      updated_at INTEGER NOT NULL,
-      PRIMARY KEY (provider, model, provider_key, hash)
-    );
-  `);
-	params.db.exec(`CREATE INDEX IF NOT EXISTS idx_embedding_cache_updated_at ON ${params.embeddingCacheTable}(updated_at);`);
-	let ftsAvailable = false;
-	let ftsError;
-	if (params.ftsEnabled) try {
-		params.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${params.ftsTable} USING fts5(\n  text,\n  id UNINDEXED,\n  path UNINDEXED,\n  source UNINDEXED,\n  model UNINDEXED,\n  start_line UNINDEXED,\n  end_line UNINDEXED\n);`);
-		ftsAvailable = true;
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		ftsAvailable = false;
-		ftsError = message;
-	}
-	ensureColumn(params.db, "files", "source", "TEXT NOT NULL DEFAULT 'memory'");
-	ensureColumn(params.db, "chunks", "source", "TEXT NOT NULL DEFAULT 'memory'");
-	params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);`);
-	params.db.exec(`CREATE INDEX IF NOT EXISTS idx_chunks_source ON chunks(source);`);
-	return {
-		ftsAvailable,
-		...ftsError ? { ftsError } : {}
-	};
-}
-function ensureColumn(db, table, column, definition) {
-	if (db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column)) return;
-	db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
-}
-
-//#endregion
-//#region src/memory/manager-search.ts
-function truncateUtf16Safe(input, maxChars) {
-	if (input.length <= maxChars) return input;
-	return input.slice(0, maxChars);
-}
-const vectorToBlob = (embedding) => Buffer.from(new Float32Array(embedding).buffer);
-async function searchVector(params) {
-	if (params.queryVec.length === 0 || params.limit <= 0) return [];
-	if (await params.ensureVectorReady(params.queryVec.length)) return params.db.prepare(`SELECT c.id, c.path, c.start_line, c.end_line, c.text,
-       c.source,
-       vec_distance_cosine(v.embedding, ?) AS dist
-  FROM ${params.vectorTable} v\n  JOIN chunks c ON c.id = v.id\n WHERE c.model = ?${params.sourceFilterVec.sql}\n ORDER BY dist ASC\n LIMIT ?`).all(vectorToBlob(params.queryVec), params.providerModel, ...params.sourceFilterVec.params, params.limit).map((row) => ({
-		id: row.id,
-		path: row.path,
-		startLine: row.start_line,
-		endLine: row.end_line,
-		score: 1 - row.dist,
-		snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
-		source: row.source
-	}));
-	return listChunks({
-		db: params.db,
-		providerModel: params.providerModel,
-		sourceFilter: params.sourceFilterChunks
-	}).map((chunk) => ({
-		chunk,
-		score: cosineSimilarity(params.queryVec, chunk.embedding)
-	})).filter((entry) => Number.isFinite(entry.score)).slice().sort((a, b) => b.score - a.score).slice(0, params.limit).map((entry) => ({
-		id: entry.chunk.id,
-		path: entry.chunk.path,
-		startLine: entry.chunk.startLine,
-		endLine: entry.chunk.endLine,
-		score: entry.score,
-		snippet: truncateUtf16Safe(entry.chunk.text, params.snippetMaxChars),
-		source: entry.chunk.source
-	}));
-}
-function listChunks(params) {
-	return params.db.prepare(`SELECT id, path, start_line, end_line, text, embedding, source
-  FROM chunks
- WHERE model = ?${params.sourceFilter.sql}`).all(params.providerModel, ...params.sourceFilter.params).map((row) => ({
-		id: row.id,
-		path: row.path,
-		startLine: row.start_line,
-		endLine: row.end_line,
-		text: row.text,
-		embedding: parseEmbedding(row.embedding),
-		source: row.source
-	}));
-}
-async function searchKeyword(params) {
-	if (params.limit <= 0) return [];
-	const ftsQuery = params.buildFtsQuery(params.query);
-	if (!ftsQuery) return [];
-	const modelClause = params.providerModel ? " AND model = ?" : "";
-	const modelParams = params.providerModel ? [params.providerModel] : [];
-	return params.db.prepare(`SELECT id, path, source, start_line, end_line, text,\n       bm25(${params.ftsTable}) AS rank\n  FROM ${params.ftsTable}\n WHERE ${params.ftsTable} MATCH ?${modelClause}${params.sourceFilter.sql}\n ORDER BY rank ASC\n LIMIT ?`).all(ftsQuery, ...modelParams, ...params.sourceFilter.params, params.limit).map((row) => {
-		const textScore = params.bm25RankToScore(row.rank);
-		return {
-			id: row.id,
-			path: row.path,
-			startLine: row.start_line,
-			endLine: row.end_line,
-			score: textScore,
-			textScore,
-			snippet: truncateUtf16Safe(row.text, params.snippetMaxChars),
-			source: row.source
-		};
-	});
-}
-
-//#endregion
-//#region src/memory/sqlite.ts
-const require = createRequire(import.meta.url);
-function requireNodeSqlite() {
-	try {
-		return require("node:sqlite");
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		throw new Error(`SQLite support is unavailable in this Node runtime (missing node:sqlite). ${message}`, { cause: err });
-	}
-}
-
-//#endregion
-//#region src/memory/config.ts
-const DEFAULT_MEMORY_SEARCH_CONFIG = {
-	chunkTokens: 400,
-	chunkOverlap: 80,
-	maxResults: 6,
-	minScore: .35,
-	experimental: { sessionMemory: false },
-	sources: ["memory"],
-	store: { vector: { enabled: true } },
-	hybrid: {
-		enabled: true,
-		vectorWeight: .7,
-		textWeight: .3,
-		candidateMultiplier: 4,
-		mmr: {
-			enabled: false,
-			lambda: .7
-		},
-		temporalDecay: {
-			enabled: false,
-			halfLifeDays: 30
-		}
-	},
-	cache: {
-		enabled: true,
-		maxEntries: 5e4
-	},
-	sync: {
-		onSessionStart: true,
-		onSearch: true,
-		watch: true,
-		watchDebounceMs: 1500,
-		sessions: {
-			deltaBytes: 1e5,
-			deltaMessages: 50
-		}
-	},
-	citations: "auto"
-};
-
-//#endregion
-//#region src/memory/sqlite-vec.ts
-async function loadSqliteVecExtension(params) {
-	try {
-		const sqliteVec = await import("sqlite-vec");
-		const resolvedPath = params.extensionPath?.trim() ? params.extensionPath.trim() : void 0;
-		const extensionPath = resolvedPath ?? sqliteVec.getLoadablePath();
-		params.db.enableLoadExtension(true);
-		if (resolvedPath) params.db.loadExtension(extensionPath);
-		else sqliteVec.load(params.db);
-		return {
-			ok: true,
-			extensionPath
-		};
-	} catch (err) {
-		return {
-			ok: false,
-			error: err instanceof Error ? err.message : String(err)
-		};
-	}
-}
-
-//#endregion
-//#region src/memory/session-files.ts
-function sessionPathForFile(dataDir, absPath) {
-	const root = sessionsDir(dataDir);
-	return path.relative(root, absPath).replace(/\\/g, "/");
-}
-async function listSessionFilesForAgent(dataDir) {
-	const root = sessionsDir(dataDir);
-	try {
-		const entries = await fs.readdir(root, { withFileTypes: true });
-		const files = [];
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			const transcript = path.join(root, entry.name, "transcript.jsonl");
-			try {
-				if ((await fs.stat(transcript)).isFile()) files.push(transcript);
-			} catch {}
-		}
-		return files;
-	} catch (err) {
-		if (isFileMissingError(err)) return [];
-		throw err;
-	}
-}
-function stringifyContent(raw) {
-	if (typeof raw === "string") return raw;
-	if (Array.isArray(raw)) return raw.map((item) => {
-		if (typeof item === "string") return item;
-		if (item && typeof item === "object" && "text" in item) return String(item.text ?? "");
-		return "";
-	}).filter(Boolean).join(" ");
-	return raw ? String(raw) : "";
-}
-async function buildSessionEntry(dataDir, absPath) {
-	let stat;
-	try {
-		stat = await fs.stat(absPath);
-	} catch (err) {
-		if (isFileMissingError(err)) return null;
-		throw err;
-	}
-	let content;
-	try {
-		content = await fs.readFile(absPath, "utf-8");
-	} catch (err) {
-		if (isFileMissingError(err)) return null;
-		throw err;
-	}
-	const lines = [];
-	const lineMap = [];
-	const rawLines = content.split("\n");
-	for (let i = 0; i < rawLines.length; i += 1) {
-		const trimmed = rawLines[i]?.trim();
-		if (!trimmed) continue;
-		try {
-			const parsed = JSON.parse(trimmed);
-			const role = parsed.role ?? "unknown";
-			const text = stringifyContent(parsed.content);
-			if (!text) continue;
-			const entryLines = text.split("\n");
-			for (const entryLine of entryLines) {
-				lines.push(`[${role}] ${entryLine}`);
-				lineMap.push(i + 1);
-			}
-		} catch {}
-	}
-	const flattened = lines.join("\n");
-	const hash = hashText(flattened);
-	return {
-		path: path.join("sessions", sessionPathForFile(dataDir, absPath)).replace(/\\/g, "/"),
-		absPath,
-		mtimeMs: stat.mtimeMs,
-		size: stat.size,
-		hash,
-		content: flattened,
-		lineMap
-	};
-}
-
-//#endregion
-//#region src/memory/manager.ts
-var manager_exports = /* @__PURE__ */ __exportAll({ MemoryIndexManager: () => MemoryIndexManager });
-const SNIPPET_MAX_CHARS = 700;
-const VECTOR_TABLE = "chunks_vec";
-const FTS_TABLE = "chunks_fts";
-const EMBEDDING_CACHE_TABLE = "embedding_cache";
-const META_KEY = "memory_index_meta_v1";
-const VECTOR_LOAD_TIMEOUT_MS = 3e4;
-const MANAGER_CACHE = /* @__PURE__ */ new Map();
-function resolveConfig(base, override) {
-	const config = {
-		...base,
-		...override,
-		hybrid: {
-			...base.hybrid,
-			...override?.hybrid ?? {}
-		},
-		cache: {
-			...base.cache,
-			...override?.cache ?? {}
-		},
-		sync: {
-			...base.sync,
-			...override?.sync ?? {}
-		},
-		experimental: {
-			...base.experimental,
-			...override?.experimental ?? {}
-		},
-		sources: override?.sources ?? base.sources,
-		store: {
-			...base.store,
-			...override?.store ?? {},
-			vector: {
-				...base.store.vector,
-				...override?.store?.vector ?? {}
-			}
-		}
-	};
-	if (config.experimental.sessionMemory && !config.sources.includes("sessions")) config.sources = [...config.sources, "sessions"];
-	return config;
-}
-var MemoryIndexManager = class MemoryIndexManager {
-	dataDir;
-	memoryRoot;
-	storePath;
-	config;
-	provider;
-	providerKey;
-	db;
-	dirty = true;
-	ftsAvailable = false;
-	ftsError;
-	vector = {
-		enabled: true,
-		available: null,
-		extensionPath: void 0,
-		loadError: void 0,
-		dims: void 0
-	};
-	vectorReady = null;
-	watchers = [];
-	watchTimer = null;
-	sessionWatchTimer = null;
-	sessionsDirty = false;
-	sessionsDirtyFiles = /* @__PURE__ */ new Set();
-	sessionPendingFiles = /* @__PURE__ */ new Set();
-	sessionDeltas = /* @__PURE__ */ new Map();
-	static get(dataDir, config) {
-		const memoryRoot = path.join(dataDir, ".pingclaw", "memory");
-		const existing = MANAGER_CACHE.get(memoryRoot);
-		if (existing) {
-			if (config) existing.applyConfig(config);
-			return existing;
-		}
-		const manager = new MemoryIndexManager(dataDir, memoryRoot, config);
-		MANAGER_CACHE.set(memoryRoot, manager);
-		return manager;
-	}
-	constructor(dataDir, memoryRoot, config) {
-		this.dataDir = dataDir;
-		this.memoryRoot = memoryRoot;
-		this.storePath = path.join(memoryRoot, ".index.sqlite");
-		this.config = resolveConfig(DEFAULT_MEMORY_SEARCH_CONFIG, config);
-		this.provider = createMockEmbeddingProvider();
-		this.providerKey = this.computeProviderKey();
-		this.vector.enabled = this.config.store.vector.enabled;
-		this.vector.extensionPath = this.config.store.vector.extensionPath;
-		this.db = this.openDatabase();
-		this.ensureSchema();
-		this.ensureWatcher();
-		this.ensureSessionListener();
-		this.dirty = true;
-	}
-	applyConfig(config) {
-		this.config = resolveConfig(this.config, config);
-		this.vector.enabled = this.config.store.vector.enabled;
-		this.vector.extensionPath = this.config.store.vector.extensionPath;
-		this.ensureWatcher();
-		this.ensureSessionListener();
-	}
-	warmSession() {
-		if (!this.config.sync.onSessionStart) return;
-		this.sync({ reason: "session-start" }).catch(() => {});
-	}
-	noteSessionUpdate(sessionFile) {
-		this.scheduleSessionDirty(sessionFile);
-	}
-	status() {
-		const sourceFilter = this.buildSourceFilter();
-		const files = this.db.prepare(`SELECT COUNT(*) as c FROM files WHERE 1=1${sourceFilter.sql}`).get(...sourceFilter.params);
-		const chunks = this.db.prepare(`SELECT COUNT(*) as c FROM chunks WHERE 1=1${sourceFilter.sql}`).get(...sourceFilter.params);
-		const sourceCounts = (() => {
-			const sources = Array.from(this.config.sources);
-			if (sources.length === 0) return [];
-			const bySource = /* @__PURE__ */ new Map();
-			for (const source of sources) bySource.set(source, {
-				files: 0,
-				chunks: 0
-			});
-			const fileRows = this.db.prepare(`SELECT source, COUNT(*) as c FROM files WHERE 1=1${sourceFilter.sql} GROUP BY source`).all(...sourceFilter.params);
-			for (const row of fileRows) {
-				const entry = bySource.get(row.source) ?? {
-					files: 0,
-					chunks: 0
-				};
-				entry.files = row.c ?? 0;
-				bySource.set(row.source, entry);
-			}
-			const chunkRows = this.db.prepare(`SELECT source, COUNT(*) as c FROM chunks WHERE 1=1${sourceFilter.sql} GROUP BY source`).all(...sourceFilter.params);
-			for (const row of chunkRows) {
-				const entry = bySource.get(row.source) ?? {
-					files: 0,
-					chunks: 0
-				};
-				entry.chunks = row.c ?? 0;
-				bySource.set(row.source, entry);
-			}
-			return sources.map((source) => Object.assign({ source }, bySource.get(source)));
-		})();
-		const searchMode = this.provider ? "hybrid" : "fts-only";
-		const cacheEntries = this.config.cache.enabled ? this.db.prepare(`SELECT COUNT(*) as c FROM ${EMBEDDING_CACHE_TABLE}`).get()?.c ?? 0 : void 0;
-		return {
-			backend: "builtin",
-			files: files?.c ?? 0,
-			chunks: chunks?.c ?? 0,
-			dirty: this.dirty || this.sessionsDirty,
-			workspaceDir: this.memoryRoot,
-			dbPath: this.storePath,
-			provider: this.provider.id,
-			model: this.provider.model,
-			sources: Array.from(this.config.sources),
-			sourceCounts,
-			cache: this.config.cache.enabled ? {
-				enabled: true,
-				entries: cacheEntries,
-				maxEntries: this.config.cache.maxEntries
-			} : {
-				enabled: false,
-				maxEntries: this.config.cache.maxEntries
-			},
-			fts: {
-				enabled: this.config.hybrid.enabled,
-				available: this.ftsAvailable,
-				error: this.ftsError
-			},
-			vector: {
-				enabled: this.vector.enabled,
-				available: this.vector.available ?? void 0,
-				extensionPath: this.vector.extensionPath,
-				loadError: this.vector.loadError,
-				dims: this.vector.dims
-			},
-			custom: { searchMode }
-		};
-	}
-	async probeEmbeddingAvailability() {
-		try {
-			await this.provider.embedBatch(["ping"]);
-			return { ok: true };
-		} catch (err) {
-			return {
-				ok: false,
-				error: err instanceof Error ? err.message : String(err)
-			};
-		}
-	}
-	async probeVectorAvailability() {
-		if (!this.vector.enabled) return false;
-		return await this.ensureVectorReady();
-	}
-	async search(query) {
-		const cleaned = query.trim();
-		if (!cleaned) return [];
-		if (!this.readMeta()) await this.sync({ reason: "boot" });
-		else if (this.config.sync.onSearch && (this.dirty || this.sessionsDirty)) this.sync({ reason: "search" }).catch(() => {});
-		const hybrid = this.config.hybrid;
-		const candidates = Math.min(200, Math.max(1, Math.floor(this.config.maxResults * hybrid.candidateMultiplier)));
-		const keywordResults = hybrid.enabled && this.ftsAvailable ? await this.searchKeyword(cleaned, candidates).catch(() => []) : [];
-		const queryVec = await this.provider.embedQuery(cleaned);
-		const vectorResults = queryVec.some((v) => v !== 0) ? await this.searchVector(queryVec, candidates).catch(() => []) : [];
-		if (!hybrid.enabled || !this.ftsAvailable) return vectorResults.filter((entry) => entry.score >= this.config.minScore).slice(0, this.config.maxResults);
-		const merged = await mergeHybridResults({
-			vector: vectorResults.map((r) => ({
-				id: `${r.path}:${r.startLine}:${r.endLine}:${r.source}`,
-				path: r.path,
-				startLine: r.startLine,
-				endLine: r.endLine,
-				source: r.source,
-				snippet: r.snippet,
-				vectorScore: r.score
-			})),
-			keyword: keywordResults.map((r) => ({
-				id: `${r.path}:${r.startLine}:${r.endLine}:${r.source}`,
-				path: r.path,
-				startLine: r.startLine,
-				endLine: r.endLine,
-				source: r.source,
-				snippet: r.snippet,
-				textScore: r.textScore
-			})),
-			vectorWeight: hybrid.vectorWeight,
-			textWeight: hybrid.textWeight,
-			mmr: hybrid.mmr,
-			temporalDecay: hybrid.temporalDecay,
-			memoryRoot: this.memoryRoot
-		});
-		const strict = merged.filter((entry) => entry.score >= this.config.minScore);
-		if (strict.length > 0 || keywordResults.length === 0) return this.decorateCitations(strict.slice(0, this.config.maxResults));
-		const relaxedMinScore = Math.min(this.config.minScore, hybrid.textWeight);
-		const relaxedResults = merged.filter((entry) => entry.score >= relaxedMinScore).slice(0, this.config.maxResults);
-		return this.decorateCitations(relaxedResults);
-	}
-	async readFile(params) {
-		const rawPath = params.relPath.trim();
-		if (!rawPath) throw new Error("path required");
-		const absPath = path.isAbsolute(rawPath) ? path.resolve(rawPath) : path.resolve(this.memoryRoot, rawPath);
-		const relPath = path.relative(this.memoryRoot, absPath).replace(/\\/g, "/");
-		if (!(relPath.length > 0 && !relPath.startsWith("..") && !path.isAbsolute(relPath) && isMemoryPath(relPath))) throw new Error("path required");
-		if (!absPath.endsWith(".md")) throw new Error("path required");
-		if ((await statRegularFile(absPath)).missing) return {
-			text: "",
-			path: relPath
-		};
-		let content;
-		try {
-			content = await fs.readFile(absPath, "utf-8");
-		} catch (err) {
-			if (isFileMissingError(err)) return {
-				text: "",
-				path: relPath
-			};
-			throw err;
-		}
-		if (!params.from && !params.lines) return {
-			text: content,
-			path: relPath
-		};
-		const lines = content.split("\n");
-		const start = Math.max(1, params.from ?? 1);
-		const count = Math.max(1, params.lines ?? lines.length);
-		return {
-			text: lines.slice(start - 1, start - 1 + count).join("\n"),
-			path: relPath
-		};
-	}
-	async appendToMemory(content) {
-		const dir = this.memoryRoot;
-		await fs.mkdir(dir, { recursive: true });
-		const filePath = path.join(dir, "MEMORY.md");
-		const entry = content.endsWith("\n") ? content : `${content}\n`;
-		await fs.appendFile(filePath, entry, "utf-8");
-		this.dirty = true;
-	}
-	openDatabase() {
-		ensureDir(path.dirname(this.storePath));
-		const { DatabaseSync } = requireNodeSqlite();
-		return new DatabaseSync(this.storePath, { allowExtension: this.vector.enabled });
-	}
-	ensureSchema() {
-		const result = ensureMemoryIndexSchema({
-			db: this.db,
-			embeddingCacheTable: EMBEDDING_CACHE_TABLE,
-			ftsTable: FTS_TABLE,
-			ftsEnabled: this.config.hybrid.enabled
-		});
-		this.ftsAvailable = result.ftsAvailable;
-		if (result.ftsError) this.ftsError = result.ftsError;
-	}
-	async ensureVectorReady(dimensions) {
-		if (!this.vector.enabled) return false;
-		if (!this.vectorReady) this.vectorReady = this.withTimeout(this.loadVectorExtension(), VECTOR_LOAD_TIMEOUT_MS, `sqlite-vec load timed out after ${Math.round(VECTOR_LOAD_TIMEOUT_MS / 1e3)}s`);
-		let ready = false;
-		try {
-			ready = await this.vectorReady || false;
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			this.vector.available = false;
-			this.vector.loadError = message;
-			this.vectorReady = null;
-			return false;
-		}
-		if (ready && typeof dimensions === "number" && dimensions > 0) this.ensureVectorTable(dimensions);
-		return ready;
-	}
-	async loadVectorExtension() {
-		if (this.vector.available !== null) return this.vector.available;
-		if (!this.vector.enabled) {
-			this.vector.available = false;
-			return false;
-		}
-		try {
-			const resolvedPath = this.vector.extensionPath?.trim() ? this.vector.extensionPath.trim() : void 0;
-			const loaded = await loadSqliteVecExtension({
-				db: this.db,
-				extensionPath: resolvedPath
-			});
-			if (!loaded.ok) throw new Error(loaded.error ?? "unknown sqlite-vec load error");
-			this.vector.extensionPath = loaded.extensionPath;
-			this.vector.available = true;
-			return true;
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			this.vector.available = false;
-			this.vector.loadError = message;
-			return false;
-		}
-	}
-	ensureVectorTable(dimensions) {
-		if (this.vector.dims === dimensions) return;
-		if (this.vector.dims && this.vector.dims !== dimensions) this.dropVectorTable();
-		this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${VECTOR_TABLE} USING vec0(\n  id TEXT PRIMARY KEY,\n  embedding FLOAT[${dimensions}]\n)`);
-		this.vector.dims = dimensions;
-	}
-	dropVectorTable() {
-		try {
-			this.db.exec(`DROP TABLE IF EXISTS ${VECTOR_TABLE}`);
-		} catch {}
-	}
-	async withTimeout(promise, timeoutMs, message) {
-		if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return await promise;
-		let timer = null;
-		const timeoutPromise = new Promise((_, reject) => {
-			timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-		});
-		try {
-			return await Promise.race([promise, timeoutPromise]);
-		} finally {
-			if (timer) clearTimeout(timer);
-		}
-	}
-	ensureWatcher() {
-		if (!this.config.sync.watch || this.watchers.length > 0) return;
-		const watchTargets = [this.memoryRoot, path.join(this.memoryRoot, "memory")];
-		const onChange = () => {
-			this.dirty = true;
-			this.scheduleWatchSync();
-		};
-		for (const target of watchTargets) try {
-			const watcher = fsSync.watch(target, { recursive: false }, onChange);
-			this.watchers.push(watcher);
-		} catch {}
-	}
-	scheduleWatchSync() {
-		if (!this.config.sync.watch) return;
-		if (this.watchTimer) clearTimeout(this.watchTimer);
-		this.watchTimer = setTimeout(() => {
-			this.watchTimer = null;
-			this.sync({ reason: "watch" }).catch(() => {});
-		}, this.config.sync.watchDebounceMs);
-	}
-	ensureSessionListener() {
-		if (!this.config.experimental.sessionMemory) return;
-		const sessionsRoot = path.join(this.dataDir, ".pingclaw", "sessions");
-		try {
-			const watcher = fsSync.watch(sessionsRoot, { recursive: true }, (_event, filename) => {
-				if (!filename || !filename.endsWith("transcript.jsonl")) return;
-				const abs = path.join(sessionsRoot, filename);
-				this.scheduleSessionDirty(abs);
-			});
-			this.watchers.push(watcher);
-		} catch {}
-	}
-	scheduleSessionDirty(sessionFile) {
-		if (!this.config.experimental.sessionMemory) return;
-		this.sessionPendingFiles.add(sessionFile);
-		if (this.sessionWatchTimer) return;
-		this.sessionWatchTimer = setTimeout(() => {
-			this.sessionWatchTimer = null;
-			this.processSessionDeltaBatch().catch(() => {});
-		}, 5e3);
-	}
-	async processSessionDeltaBatch() {
-		if (this.sessionPendingFiles.size === 0) return;
-		const pending = Array.from(this.sessionPendingFiles);
-		this.sessionPendingFiles.clear();
-		let shouldSync = false;
-		for (const sessionFile of pending) {
-			const delta = await this.updateSessionDelta(sessionFile);
-			if (!delta) continue;
-			const bytesThreshold = delta.deltaBytes;
-			const messagesThreshold = delta.deltaMessages;
-			const bytesHit = bytesThreshold <= 0 ? delta.pendingBytes > 0 : delta.pendingBytes >= bytesThreshold;
-			const messagesHit = messagesThreshold <= 0 ? delta.pendingMessages > 0 : delta.pendingMessages >= messagesThreshold;
-			if (!bytesHit && !messagesHit) continue;
-			this.sessionsDirtyFiles.add(sessionFile);
-			this.sessionsDirty = true;
-			delta.pendingBytes = bytesThreshold > 0 ? Math.max(0, delta.pendingBytes - bytesThreshold) : 0;
-			delta.pendingMessages = messagesThreshold > 0 ? Math.max(0, delta.pendingMessages - messagesThreshold) : 0;
-			shouldSync = true;
-		}
-		if (shouldSync) this.sync({ reason: "session-delta" }).catch(() => {});
-	}
-	async updateSessionDelta(sessionFile) {
-		const thresholds = this.config.sync.sessions;
-		if (!thresholds) return null;
-		let stat;
-		try {
-			stat = await fs.stat(sessionFile);
-		} catch {
-			return null;
-		}
-		const size = stat.size;
-		let state = this.sessionDeltas.get(sessionFile);
-		if (!state) {
-			state = {
-				lastSize: 0,
-				pendingBytes: 0,
-				pendingMessages: 0
-			};
-			this.sessionDeltas.set(sessionFile, state);
-		}
-		const deltaBytes = Math.max(0, size - state.lastSize);
-		if (deltaBytes === 0 && size === state.lastSize) return {
-			deltaBytes: thresholds.deltaBytes,
-			deltaMessages: thresholds.deltaMessages,
-			pendingBytes: state.pendingBytes,
-			pendingMessages: state.pendingMessages
-		};
-		if (size < state.lastSize) {
-			state.lastSize = size;
-			state.pendingBytes += size;
-			if (thresholds.deltaMessages > 0 && (thresholds.deltaBytes <= 0 || state.pendingBytes < thresholds.deltaBytes)) state.pendingMessages += await this.countNewlines(sessionFile, 0, size);
-		} else {
-			state.pendingBytes += deltaBytes;
-			if (thresholds.deltaMessages > 0 && (thresholds.deltaBytes <= 0 || state.pendingBytes < thresholds.deltaBytes)) state.pendingMessages += await this.countNewlines(sessionFile, state.lastSize, size);
-			state.lastSize = size;
-		}
-		this.sessionDeltas.set(sessionFile, state);
-		return {
-			deltaBytes: thresholds.deltaBytes,
-			deltaMessages: thresholds.deltaMessages,
-			pendingBytes: state.pendingBytes,
-			pendingMessages: state.pendingMessages
-		};
-	}
-	async countNewlines(absPath, start, end) {
-		if (end <= start) return 0;
-		let handle;
-		try {
-			handle = await fs.open(absPath, "r");
-		} catch {
-			return 0;
-		}
-		try {
-			let offset = start;
-			let count = 0;
-			const buffer = Buffer.alloc(64 * 1024);
-			while (offset < end) {
-				const toRead = Math.min(buffer.length, end - offset);
-				const { bytesRead } = await handle.read(buffer, 0, toRead, offset);
-				if (bytesRead <= 0) break;
-				for (let i = 0; i < bytesRead; i += 1) if (buffer[i] === 10) count += 1;
-				offset += bytesRead;
-			}
-			return count;
-		} finally {
-			await handle.close();
-		}
-	}
-	computeProviderKey() {
-		return hashText(JSON.stringify({
-			provider: this.provider.id,
-			model: this.provider.model
-		}));
-	}
-	readMeta() {
-		const row = this.db.prepare(`SELECT value FROM meta WHERE key = ?`).get(META_KEY);
-		if (!row?.value) return null;
-		try {
-			return JSON.parse(row.value);
-		} catch {
-			return null;
-		}
-	}
-	writeMeta(meta) {
-		const value = JSON.stringify(meta);
-		this.db.prepare(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(META_KEY, value);
-	}
-	loadEmbeddingCache(hashes) {
-		if (!this.config.cache.enabled || hashes.length === 0) return /* @__PURE__ */ new Map();
-		const unique = Array.from(new Set(hashes.filter(Boolean)));
-		if (unique.length === 0) return /* @__PURE__ */ new Map();
-		const out = /* @__PURE__ */ new Map();
-		const baseParams = [
-			this.provider.id,
-			this.provider.model,
-			this.providerKey
-		];
-		const batchSize = 400;
-		for (let start = 0; start < unique.length; start += batchSize) {
-			const batch = unique.slice(start, start + batchSize);
-			const placeholders = batch.map(() => "?").join(", ");
-			const rows = this.db.prepare(`SELECT hash, embedding FROM ${EMBEDDING_CACHE_TABLE}\n WHERE provider = ? AND model = ? AND provider_key = ? AND hash IN (${placeholders})`).all(...baseParams, ...batch);
-			for (const row of rows) out.set(row.hash, parseEmbedding(row.embedding));
-		}
-		return out;
-	}
-	upsertEmbeddingCache(entries) {
-		if (!this.config.cache.enabled || entries.length === 0) return;
-		const now = Date.now();
-		const stmt = this.db.prepare(`INSERT INTO ${EMBEDDING_CACHE_TABLE} (provider, model, provider_key, hash, embedding, dims, updated_at)\n VALUES (?, ?, ?, ?, ?, ?, ?)\n ON CONFLICT(provider, model, provider_key, hash) DO UPDATE SET\n   embedding=excluded.embedding,\n   dims=excluded.dims,\n   updated_at=excluded.updated_at`);
-		for (const entry of entries) {
-			const embedding = entry.embedding ?? [];
-			stmt.run(this.provider.id, this.provider.model, this.providerKey, entry.hash, JSON.stringify(embedding), embedding.length, now);
-		}
-	}
-	async embedChunks(chunks) {
-		if (chunks.length === 0) return [];
-		const cached = this.loadEmbeddingCache(chunks.map((chunk) => chunk.hash));
-		const embeddings = Array.from({ length: chunks.length }, () => []);
-		const missing = [];
-		for (let i = 0; i < chunks.length; i += 1) {
-			const chunk = chunks[i];
-			const hit = chunk?.hash ? cached.get(chunk.hash) : void 0;
-			if (hit && hit.length > 0) embeddings[i] = hit;
-			else if (chunk) missing.push({
-				index: i,
-				chunk
-			});
-		}
-		if (missing.length === 0) return embeddings;
-		const batchEmbeddings = await this.provider.embedBatch(missing.map((m) => m.chunk.text));
-		const toCache = [];
-		for (let i = 0; i < missing.length; i += 1) {
-			const item = missing[i];
-			const embedding = batchEmbeddings[i] ?? [];
-			embeddings[item.index] = embedding;
-			toCache.push({
-				hash: item.chunk.hash,
-				embedding
-			});
-		}
-		this.upsertEmbeddingCache(toCache);
-		return embeddings;
-	}
-	async indexFile(entry, options) {
-		const chunks = chunkMarkdown(options.content ?? await fs.readFile(entry.absPath, "utf-8"), {
-			tokens: this.config.chunkTokens,
-			overlap: this.config.chunkOverlap
-		}).filter((chunk) => chunk.text.trim().length > 0);
-		if (options.source === "sessions") remapChunkLines(chunks, options.lineMap);
-		const embeddings = await this.embedChunks(chunks);
-		const sample = embeddings.find((embedding) => embedding.length > 0);
-		const vectorReady = sample ? await this.ensureVectorReady(sample.length) : false;
-		const now = Date.now();
-		if (vectorReady) try {
-			this.db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`).run(entry.path, options.source);
-		} catch {}
-		if (this.ftsAvailable) try {
-			this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(entry.path, options.source, this.provider.model);
-		} catch {}
-		this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(entry.path, options.source);
-		for (let i = 0; i < chunks.length; i += 1) {
-			const chunk = chunks[i];
-			const embedding = embeddings[i] ?? [];
-			const id = hashText(`${options.source}:${entry.path}:${chunk.startLine}:${chunk.endLine}:${chunk.hash}:${this.provider.model}`);
-			this.db.prepare(`INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-           ON CONFLICT(id) DO UPDATE SET
-             hash=excluded.hash,
-             model=excluded.model,
-             text=excluded.text,
-             embedding=excluded.embedding,
-             updated_at=excluded.updated_at`).run(id, entry.path, options.source, chunk.startLine, chunk.endLine, chunk.hash, this.provider.model, chunk.text, JSON.stringify(embedding), now);
-			if (vectorReady && embedding.length > 0) {
-				try {
-					this.db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id = ?`).run(id);
-				} catch {}
-				this.db.prepare(`INSERT INTO ${VECTOR_TABLE} (id, embedding) VALUES (?, ?)`).run(id, Buffer.from(new Float32Array(embedding).buffer));
-			}
-			if (this.ftsAvailable) this.db.prepare(`INSERT INTO ${FTS_TABLE} (text, id, path, source, model, start_line, end_line)\n VALUES (?, ?, ?, ?, ?, ?, ?)`).run(chunk.text, id, entry.path, options.source, this.provider.model, chunk.startLine, chunk.endLine);
-		}
-		this.db.prepare(`INSERT INTO files (path, source, hash, mtime, size) VALUES (?, ?, ?, ?, ?)
-         ON CONFLICT(path) DO UPDATE SET
-           source=excluded.source,
-           hash=excluded.hash,
-           mtime=excluded.mtime,
-           size=excluded.size`).run(entry.path, options.source, entry.hash, entry.mtimeMs, entry.size);
-	}
-	buildSourceFilter() {
-		const sources = this.config.sources;
-		if (!sources.length) return {
-			sql: "",
-			params: []
-		};
-		return {
-			sql: ` AND source IN (${sources.map(() => "?").join(", ")})`,
-			params: sources
-		};
-	}
-	async searchVector(queryVec, limit) {
-		return await searchVector({
-			db: this.db,
-			vectorTable: VECTOR_TABLE,
-			providerModel: this.provider.model,
-			queryVec,
-			limit,
-			snippetMaxChars: SNIPPET_MAX_CHARS,
-			ensureVectorReady: async (dimensions) => await this.ensureVectorReady(dimensions),
-			sourceFilterVec: this.buildSourceFilter(),
-			sourceFilterChunks: this.buildSourceFilter()
-		});
-	}
-	async searchKeyword(query, limit) {
-		if (!this.ftsAvailable) return [];
-		return await searchKeyword({
-			db: this.db,
-			ftsTable: FTS_TABLE,
-			providerModel: this.provider.model,
-			query,
-			limit,
-			snippetMaxChars: SNIPPET_MAX_CHARS,
-			sourceFilter: this.buildSourceFilter(),
-			buildFtsQuery: (raw) => buildFtsQuery(raw),
-			bm25RankToScore
-		});
-	}
-	resetIndex() {
-		this.db.exec(`DELETE FROM files`);
-		this.db.exec(`DELETE FROM chunks`);
-		if (this.ftsAvailable) try {
-			this.db.exec(`DELETE FROM ${FTS_TABLE}`);
-		} catch {}
-		this.dropVectorTable();
-		this.vector.dims = void 0;
-		this.sessionsDirtyFiles.clear();
-	}
-	async sync(params) {
-		const meta = this.readMeta();
-		const needsFullReindex = !meta || meta.model !== this.provider.model || meta.provider !== this.provider.id || meta.providerKey !== this.providerKey || meta.chunkTokens !== this.config.chunkTokens || meta.chunkOverlap !== this.config.chunkOverlap || this.vector.available && !meta?.vectorDims;
-		if (needsFullReindex) this.resetIndex();
-		const files = await listMemoryFiles(this.memoryRoot);
-		const fileEntries = (await Promise.all(files.map(async (file) => buildFileEntry(file, this.memoryRoot)))).filter((entry) => entry !== null);
-		const activePaths = new Set(fileEntries.map((entry) => entry.path));
-		const tasks = fileEntries.map((entry) => async () => {
-			const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "memory");
-			if (!needsFullReindex && record?.hash === entry.hash) return;
-			await this.indexFile(entry, { source: "memory" });
-		});
-		for (const task of tasks) await task();
-		const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("memory");
-		for (const stale of staleRows) {
-			if (activePaths.has(stale.path)) continue;
-			this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "memory");
-			try {
-				this.db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`).run(stale.path, "memory");
-			} catch {}
-			this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "memory");
-			if (this.ftsAvailable) try {
-				this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(stale.path, "memory", this.provider.model);
-			} catch {}
-		}
-		if (this.config.experimental.sessionMemory && (needsFullReindex || this.sessionsDirty)) await this.syncSessionFiles(needsFullReindex);
-		this.writeMeta({
-			model: this.provider.model,
-			provider: this.provider.id,
-			providerKey: this.providerKey,
-			chunkTokens: this.config.chunkTokens,
-			chunkOverlap: this.config.chunkOverlap,
-			...this.vector.available && this.vector.dims ? { vectorDims: this.vector.dims } : {}
-		});
-		this.dirty = false;
-	}
-	async syncSessionFiles(needsFullReindex) {
-		const files = await listSessionFilesForAgent(this.dataDir);
-		const entries = (await Promise.all(files.map(async (absPath) => buildSessionEntry(this.dataDir, absPath)))).filter((entry) => entry !== null);
-		const activePaths = new Set(entries.map((entry) => entry.path));
-		const indexAll = needsFullReindex || this.sessionsDirtyFiles.size === 0;
-		for (const entry of entries) {
-			if (!indexAll && !this.sessionsDirtyFiles.has(entry.absPath)) continue;
-			const record = this.db.prepare(`SELECT hash FROM files WHERE path = ? AND source = ?`).get(entry.path, "sessions");
-			if (!needsFullReindex && record?.hash === entry.hash) {
-				this.resetSessionDelta(entry.absPath, entry.size);
-				continue;
-			}
-			await this.indexFile(entry, {
-				source: "sessions",
-				content: entry.content,
-				lineMap: entry.lineMap
-			});
-			this.resetSessionDelta(entry.absPath, entry.size);
-		}
-		const staleRows = this.db.prepare(`SELECT path FROM files WHERE source = ?`).all("sessions");
-		for (const stale of staleRows) {
-			if (activePaths.has(stale.path)) continue;
-			this.db.prepare(`DELETE FROM files WHERE path = ? AND source = ?`).run(stale.path, "sessions");
-			try {
-				this.db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id IN (SELECT id FROM chunks WHERE path = ? AND source = ?)`).run(stale.path, "sessions");
-			} catch {}
-			this.db.prepare(`DELETE FROM chunks WHERE path = ? AND source = ?`).run(stale.path, "sessions");
-			if (this.ftsAvailable) try {
-				this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`).run(stale.path, "sessions", this.provider.model);
-			} catch {}
-		}
-		this.sessionsDirty = false;
-		this.sessionsDirtyFiles.clear();
-	}
-	resetSessionDelta(absPath, size) {
-		const state = this.sessionDeltas.get(absPath);
-		if (!state) return;
-		state.lastSize = size;
-		state.pendingBytes = 0;
-		state.pendingMessages = 0;
-	}
-	decorateCitations(results) {
-		if (this.config.citations === "off") return results;
-		return results.map((entry) => {
-			const citation = `Source: ${entry.path}#L${entry.startLine}-L${entry.endLine}`;
-			if (this.config.citations === "on") return {
-				...entry,
-				citation,
-				snippet: `${entry.snippet}\n\n${citation}`
-			};
-			return {
-				...entry,
-				citation
-			};
-		});
-	}
-};
-
-//#endregion
-export { createSession as a, listSessions as c, metadataPath as d, saveSessionMetadata as f, transcriptPath as h, appendTranscriptEntry as i, loadSessionMetadata as l, sessionsDir as m, manager_exports as n, ensureSession as o, sessionDir as p, listMemoryFiles as r, listSessionSummaries as s, MemoryIndexManager as t, loadTranscript as u };
-//# sourceMappingURL=manager-qXa-NP0p.js.map