kaijibot 2026.8.21 → 2026.8.23

package/dist/ingest-gzQEKaUE.js

@@ -0,0 +1,842 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-xZwG7Dq8.js";
+import "./text-runtime-B3UrMt6T.js";
+import path from "node:path";
+import fs, { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import YAML from "yaml";
+//#region extensions/knowledge-wiki/src/compiler.ts
+const EXTRACTION_SYSTEM_PROMPT = `You are a knowledge compiler. Read the source document and extract structured knowledge.
+
+Return a JSON object with this exact shape:
+{
+  "summary": "2-3 paragraph summary of key points. Use [[EntityName]] and [[ConceptName]] wikilinks to cross-reference extracted entities and concepts within the summary text.",
+  "claims": [{ "text": "specific factual assertion", "confidence": 0.0-1.0, "category": "domain_knowledge|technical_decision|stated_preference|process|constraint|contextual_fact|goal_or_aspiration", "evidence": "quote or paraphrase from source" }],
+  "entities": [{ "name": "named thing", "type": "person|tool|project|technology|place|organization", "description": "what it is in context" }],
+  "concepts": [{ "name": "abstract idea or methodology", "description": "explanation", "relatedTo": ["other concept names"] }],
+  "topics": ["subject area tags"],
+  "relationships": [{ "from": "entity/concept name", "to": "entity/concept name", "type": "uses|contradicts|relates-to|depends-on|part-of" }]
+}
+
+Rules:
+- Extract only what is explicitly stated or directly implied in the document
+- Confidence: 0.9+ for explicit statements, 0.7-0.9 for strong implications, 0.5-0.7 for weak implications
+- Keep claim text concise (one sentence)
+- Entity naming: use the canonical, most common English form. For "Rust" use "Rust", not "rust-language" or "Rust Programming Language". For Chinese names, use the most common form (e.g. "凯机" not "kaiji-user"). Person names: use real name if known, otherwise username.
+- Within this document, use consistent entity names — do not use "Rust" in one place and "rust-lang" in another
+- Do NOT classify abstract ideas as entities — use the concepts array for those
+- Relationships: extract all meaningful connections between entities and concepts mentioned in the document
+- Return ONLY the JSON, no markdown fences, no commentary`;
+async function extractFromSource(generateText, content, sourceMeta) {
+	const truncatedContent = content.length > 12e3 ? `${content.slice(0, 12e3)}\n\n[... truncated, ${content.length} total chars ...]` : content;
+	return parseExtractionResult(await generateText(`${EXTRACTION_SYSTEM_PROMPT}
+
+Source file: ${sourceMeta.filename}
+Path: ${sourceMeta.path}
+
+---
+${truncatedContent}
+---
+
+Extract the knowledge as JSON:`));
+}
+function parseExtractionResult(response) {
+	const jsonStr = extractJsonFromResponse(response);
+	if (!jsonStr) return createEmptyExtraction();
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonStr);
+	} catch {
+		return createEmptyExtraction();
+	}
+	if (typeof parsed !== "object" || parsed === null) return createEmptyExtraction();
+	const obj = parsed;
+	return {
+		summary: typeof obj.summary === "string" ? obj.summary : "",
+		claims: parseClaims(obj.claims),
+		entities: parseEntities(obj.entities),
+		concepts: parseConcepts(obj.concepts),
+		topics: parseTopics(obj.topics),
+		relationships: parseRelationships(obj.relationships)
+	};
+}
+function extractJsonFromResponse(response) {
+	const trimmed = response.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed;
+	const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+	if (fenceMatch && fenceMatch[1]) return fenceMatch[1].trim();
+	const jsonStart = trimmed.indexOf("{");
+	const jsonEnd = trimmed.lastIndexOf("}");
+	if (jsonStart >= 0 && jsonEnd > jsonStart) return trimmed.slice(jsonStart, jsonEnd + 1);
+	return null;
+}
+function createEmptyExtraction() {
+	return {
+		summary: "",
+		claims: [],
+		entities: [],
+		concepts: [],
+		topics: [],
+		relationships: []
+	};
+}
+function parseClaims(raw) {
+	if (!Array.isArray(raw)) return [];
+	const claims = [];
+	for (const item of raw) {
+		if (typeof item !== "object" || item === null) continue;
+		const obj = item;
+		const text = typeof obj.text === "string" ? obj.text.trim() : "";
+		if (!text) continue;
+		const confidence = typeof obj.confidence === "number" ? Math.max(0, Math.min(1, obj.confidence)) : .5;
+		const category = typeof obj.category === "string" ? obj.category : "domain_knowledge";
+		const evidence = typeof obj.evidence === "string" ? obj.evidence : void 0;
+		claims.push({
+			text,
+			confidence,
+			category,
+			...evidence ? { evidence } : {}
+		});
+	}
+	return claims;
+}
+function parseEntities(raw) {
+	if (!Array.isArray(raw)) return [];
+	const entities = [];
+	for (const item of raw) {
+		if (typeof item !== "object" || item === null) continue;
+		const obj = item;
+		const name = typeof obj.name === "string" ? obj.name.trim() : "";
+		if (!name) continue;
+		const type = typeof obj.type === "string" ? obj.type : "concept";
+		const description = typeof obj.description === "string" ? obj.description : "";
+		entities.push({
+			name,
+			type,
+			description
+		});
+	}
+	return entities;
+}
+function parseConcepts(raw) {
+	if (!Array.isArray(raw)) return [];
+	const concepts = [];
+	for (const item of raw) {
+		if (typeof item !== "object" || item === null) continue;
+		const obj = item;
+		const name = typeof obj.name === "string" ? obj.name.trim() : "";
+		if (!name) continue;
+		const description = typeof obj.description === "string" ? obj.description : "";
+		const relatedTo = Array.isArray(obj.relatedTo) ? obj.relatedTo.filter((r) => typeof r === "string") : void 0;
+		concepts.push({
+			name,
+			description,
+			...relatedTo ? { relatedTo } : {}
+		});
+	}
+	return concepts;
+}
+function parseTopics(raw) {
+	if (!Array.isArray(raw)) return [];
+	return raw.filter((t) => typeof t === "string" && t.trim().length > 0);
+}
+function parseRelationships(raw) {
+	if (!Array.isArray(raw)) return [];
+	const relationships = [];
+	for (const item of raw) {
+		if (typeof item !== "object" || item === null) continue;
+		const obj = item;
+		const from = typeof obj.from === "string" ? obj.from : "";
+		const to = typeof obj.to === "string" ? obj.to : "";
+		const type = typeof obj.type === "string" ? obj.type : "relates-to";
+		if (from && to) relationships.push({
+			from,
+			to,
+			type
+		});
+	}
+	return relationships;
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/file-state.ts
+const STATE_FILE = "file-state.json";
+function stateFilePath(vaultRoot) {
+	return path.join(vaultRoot, ".kaijibot-wiki", STATE_FILE);
+}
+function computeContentHash(content) {
+	return createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function loadFileState(vaultRoot) {
+	const statePath = stateFilePath(vaultRoot);
+	let raw;
+	try {
+		raw = await readFile(statePath, "utf8");
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	try {
+		const parsed = JSON.parse(raw);
+		const map = /* @__PURE__ */ new Map();
+		for (const entry of parsed) if (entry && typeof entry.path === "string" && typeof entry.hash === "string") map.set(entry.path, entry);
+		return map;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+async function saveFileState(vaultRoot, stateMap) {
+	const statePath = stateFilePath(vaultRoot);
+	await mkdir(path.dirname(statePath), { recursive: true });
+	const entries = [...stateMap.values()];
+	const tmpPath = `${statePath}.tmp`;
+	await writeFile(tmpPath, JSON.stringify(entries, null, 2), "utf8");
+	await rename(tmpPath, statePath);
+}
+function isFileChanged(stateMap, relativePath, currentHash) {
+	const existing = stateMap.get(relativePath);
+	if (!existing) return true;
+	return existing.hash !== currentHash;
+}
+function updateEntry(stateMap, relativePath, hash, pageIds) {
+	stateMap.set(relativePath, {
+		path: relativePath,
+		hash,
+		lastIngestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		pageIds
+	});
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/log.ts
+async function appendKnowledgeWikiLog(vaultRoot, entry) {
+	const logPath = path.join(vaultRoot, ".kaijibot-wiki", "log.jsonl");
+	await fs.mkdir(path.dirname(logPath), { recursive: true });
+	await fs.appendFile(logPath, `${JSON.stringify(entry)}\n`, "utf8");
+}
+async function appendWikiLogMarkdown(vaultRoot, entry) {
+	const logPath = path.join(vaultRoot, "log.md");
+	const date = entry.timestamp.slice(0, 10);
+	const time = entry.timestamp.slice(11, 19);
+	const source = entry.sourcePath ? ` | ${entry.sourcePath}` : "";
+	const details = entry.details && entry.details.length > 0 ? ` | ${entry.details.join(", ")}` : "";
+	const line = `## [${date} ${time}] ${entry.type}${source}${details}\n\n`;
+	await fs.mkdir(path.dirname(logPath), { recursive: true });
+	await fs.appendFile(logPath, line, "utf8");
+}
+async function appendWikiLog(vaultRoot, entry) {
+	await Promise.all([appendKnowledgeWikiLog(vaultRoot, entry), appendWikiLogMarkdown(vaultRoot, entry)]);
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/scanner.ts
+const HARDCODED_EXCLUDE_DIRS = new Set([
+	".git",
+	"node_modules",
+	".kaijibot",
+	"wiki",
+	"sessions",
+	".pnpm-store",
+	".venv",
+	"venv",
+	"dist",
+	"build",
+	"__pycache__",
+	".cache",
+	".turbo",
+	"coverage"
+]);
+const HARDCODED_EXCLUDE_PATTERNS = [
+	/\.env/i,
+	/\.pem$/i,
+	/\.key$/i,
+	/\.secret$/i
+];
+const MEMORY_LOG_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}\.md$/;
+async function scanWorkspace(workspaceDir, config) {
+	const allowedExtensions = new Set(config.scan.extensions);
+	const excludeDirs = new Set([...HARDCODED_EXCLUDE_DIRS, ...config.scan.excludeDirs]);
+	const excludePatterns = [...HARDCODED_EXCLUDE_PATTERNS, ...config.scan.excludePatterns.map((p) => new RegExp(p))];
+	const maxFileSize = config.scan.maxFileSize;
+	const includeMemoryCurated = config.scan.includeMemoryCurated;
+	const files = [];
+	const errors = [];
+	let skipped = 0;
+	async function walkDir(dir, relativeBase) {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			const relativePath = relativeBase ? `${relativeBase}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) {
+				if (excludeDirs.has(entry.name)) continue;
+				if (relativePath === "memory/dialogues") continue;
+				if (relativePath === "memory/topics/archive") continue;
+				await walkDir(fullPath, relativePath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const ext = path.extname(entry.name).toLowerCase();
+			if (!allowedExtensions.has(ext)) {
+				skipped++;
+				continue;
+			}
+			if (relativePath === "MEMORY.md" || relativePath === "memory.md") {
+				if (!includeMemoryCurated) {
+					skipped++;
+					continue;
+				}
+			} else if (relativePath.startsWith("memory/")) {
+				const filename = path.basename(relativePath);
+				if (MEMORY_LOG_DATE_PATTERN.test(filename)) {
+					skipped++;
+					continue;
+				}
+				if (relativePath.startsWith("memory/dialogues/")) {
+					skipped++;
+					continue;
+				}
+				if (relativePath.startsWith("memory/topics/") && !includeMemoryCurated) {
+					skipped++;
+					continue;
+				}
+			}
+			if (excludePatterns.some((p) => p.test(relativePath))) {
+				skipped++;
+				continue;
+			}
+			let fileStat;
+			try {
+				fileStat = await stat(fullPath);
+			} catch {
+				errors.push(`stat failed: ${relativePath}`);
+				continue;
+			}
+			if (fileStat.size > maxFileSize) {
+				skipped++;
+				continue;
+			}
+			files.push({
+				absolutePath: fullPath,
+				relativePath,
+				size: fileStat.size,
+				mtimeMs: fileStat.mtimeMs
+			});
+		}
+	}
+	await walkDir(workspaceDir, "");
+	files.toSorted((a, b) => a.relativePath.localeCompare(b.relativePath));
+	return {
+		files,
+		skipped,
+		errors
+	};
+}
+async function readFileContent(absolutePath) {
+	const buffer = await readFile(absolutePath);
+	const sample = buffer.subarray(0, Math.min(buffer.length, 8e3));
+	for (let i = 0; i < sample.length; i++) if (sample[i] === 0) throw new Error(`Binary file detected: ${absolutePath}`);
+	return buffer.toString("utf8");
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/vault.ts
+const WIKI_DIRS = [
+	"summaries",
+	"entities",
+	"concepts"
+];
+const AGENTS_MD_CONTENT = `# Wiki Agent Guide
+
+This wiki is maintained by the LLM. You read it; the LLM writes it.
+
+## Operations
+
+- **Ingest**: Read a source file → extract knowledge → write summary/entity/concept pages → update index → log
+- **Query**: Read index → find relevant pages → read pages → synthesize answer
+- **Lint**: Scan for contradictions, stale claims, orphan pages, missing cross-references
+
+## Page Types
+
+- **summaries/**: One page per ingested source. Contains summary + key claims + links to entities/concepts.
+- **entities/**: Named things (people, tools, projects, technologies). Merged across sources.
+- **concepts/**: Abstract ideas or methodologies. Merged across sources.
+
+## Conventions
+
+- All pages have YAML frontmatter with pageType, title, sourceIds, claims, updatedAt.
+- Cross-references use [[wikilinks]].
+- Claims have confidence (0-1) and evidence.
+- The LLM updates the wiki when new sources arrive. Humans read, LLM writes.
+`;
+async function initializeWikiVault(vaultRoot) {
+	const createdDirs = [];
+	const createdFiles = [];
+	for (const dir of WIKI_DIRS) {
+		await mkdir(path.join(vaultRoot, dir), { recursive: true });
+		createdDirs.push(dir);
+	}
+	await mkdir(path.join(vaultRoot, ".kaijibot-wiki"), { recursive: true });
+	await mkdir(path.join(vaultRoot, ".kaijibot-wiki", "cache"), { recursive: true });
+	const agentsPath = path.join(vaultRoot, "AGENTS.md");
+	try {
+		await writeFile(agentsPath, AGENTS_MD_CONTENT, { flag: "wx" });
+		createdFiles.push("AGENTS.md");
+	} catch {}
+	const indexPath = path.join(vaultRoot, "index.md");
+	try {
+		await writeFile(indexPath, "# Wiki Index\n\n*No pages yet.*\n", { flag: "wx" });
+		createdFiles.push("index.md");
+	} catch {}
+	const logPath = path.join(vaultRoot, "log.md");
+	try {
+		await writeFile(logPath, `## [${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19)}] init | Wiki vault initialized\n\n`, { flag: "wx" });
+		createdFiles.push("log.md");
+	} catch {}
+	return {
+		vaultPath: vaultRoot,
+		created: createdFiles.length > 0,
+		createdDirs,
+		createdFiles
+	};
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/markdown.ts
+const WIKI_RELATED_START_MARKER = "<!-- kaijibot:wiki:related:start -->";
+const WIKI_RELATED_END_MARKER = "<!-- kaijibot:wiki:related:end -->";
+const FRONTMATTER_PATTERN = /^---\n([\s\S]*?)\n---\n?/;
+const OBSIDIAN_LINK_PATTERN = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+const MARKDOWN_LINK_PATTERN = /\[[^\]]+\]\(([^)]+)\)/g;
+const RELATED_BLOCK_PATTERN = new RegExp(`${WIKI_RELATED_START_MARKER}[\\s\\S]*?${WIKI_RELATED_END_MARKER}`, "g");
+const MAX_WIKI_SEGMENT_BYTES = 240;
+const WIKI_SEGMENT_HASH_BYTES = 12;
+function truncateUtf8CodePointSafe(value, maxBytes) {
+	let result = "";
+	let bytes = 0;
+	for (const char of value) {
+		const nextBytes = Buffer.byteLength(char);
+		if (bytes + nextBytes > maxBytes) break;
+		result += char;
+		bytes += nextBytes;
+	}
+	return result;
+}
+function capWikiValueWithHash(raw, maxBytes, fallback) {
+	if (Buffer.byteLength(raw) <= maxBytes) return raw;
+	const suffix = createHash("sha1").update(raw).digest("hex").slice(0, WIKI_SEGMENT_HASH_BYTES);
+	return `${truncateUtf8CodePointSafe(raw, maxBytes - Buffer.byteLength(`-${suffix}`)).replace(/-+$/g, "") || fallback}-${suffix}`;
+}
+function slugifyWikiSegment(raw) {
+	const slug = normalizeLowercaseStringOrEmpty(raw).replace(/[^\p{L}\p{N}\p{M}]+/gu, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+	if (!slug) return "page";
+	return capWikiValueWithHash(slug, MAX_WIKI_SEGMENT_BYTES, "page");
+}
+function parseWikiMarkdown(content) {
+	const match = content.match(FRONTMATTER_PATTERN);
+	if (!match) return {
+		frontmatter: {},
+		body: content
+	};
+	const parsed = YAML.parse(match[1]);
+	return {
+		frontmatter: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {},
+		body: content.slice(match[0].length)
+	};
+}
+function renderWikiMarkdown(params) {
+	return `---\n${YAML.stringify(params.frontmatter).trimEnd()}\n---\n\n${params.body.trimStart()}`;
+}
+function extractWikiLinks(markdown) {
+	const searchable = markdown.replace(RELATED_BLOCK_PATTERN, "");
+	const links = [];
+	for (const match of searchable.matchAll(OBSIDIAN_LINK_PATTERN)) {
+		const target = match[1]?.trim();
+		if (target) links.push(target);
+	}
+	for (const match of searchable.matchAll(MARKDOWN_LINK_PATTERN)) {
+		const rawTarget = match[1]?.trim();
+		if (!rawTarget || rawTarget.startsWith("#") || /^[a-z]+:/i.test(rawTarget)) continue;
+		const target = rawTarget.split("#")[0]?.split("?")[0]?.replace(/\\/g, "/").trim();
+		if (target) links.push(target);
+	}
+	return links;
+}
+function inferWikiPageKind(relativePath) {
+	const normalized = relativePath.split(path.sep).join("/");
+	if (normalized.startsWith("entities/")) return "entity";
+	if (normalized.startsWith("concepts/")) return "concept";
+	if (normalized.startsWith("sources/")) return "source";
+	if (normalized.startsWith("syntheses/")) return "synthesis";
+	if (normalized.startsWith("reports/")) return "report";
+	if (normalized.startsWith("summaries/")) return "summary";
+	return null;
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/wiki-writer.ts
+async function atomicWrite(filePath, content) {
+	await mkdir(path.dirname(filePath), { recursive: true });
+	const tmpPath = `${filePath}.tmp`;
+	await writeFile(tmpPath, content, "utf8");
+	await rename(tmpPath, filePath);
+}
+function summaryPagePath(sourceRelativePath) {
+	const slug = slugifyWikiSegment(sourceRelativePath.replace(/\.[^.]+$/, ""));
+	return path.join("summaries", `${slug}.md`);
+}
+function entityPagePath(entityName) {
+	const slug = slugifyWikiSegment(entityName);
+	return path.join("entities", `${slug}.md`);
+}
+function conceptPagePath(conceptName) {
+	const slug = slugifyWikiSegment(conceptName);
+	return path.join("concepts", `${slug}.md`);
+}
+async function writeSummaryPage(vaultRoot, sourcePath, extraction) {
+	const relativePath = summaryPagePath(sourcePath);
+	const absolutePath = path.join(vaultRoot, relativePath);
+	const slug = slugifyWikiSegment(sourcePath.replace(/\.[^.]+$/, ""));
+	const claims = extraction.claims.slice(0, 20).map((c) => ({
+		text: c.text,
+		confidence: c.confidence,
+		status: "active",
+		evidence: c.evidence ? [{ note: c.evidence }] : []
+	}));
+	const entityLinks = extraction.entities.map((e) => `[[${slugifyWikiSegment(e.name)}]]`).join(", ");
+	const conceptLinks = extraction.concepts.map((c) => `[[${slugifyWikiSegment(c.name)}]]`).join(", ");
+	const relationshipLines = extraction.relationships.length > 0 ? extraction.relationships.map((r) => `- [[${slugifyWikiSegment(r.from)}]] ${r.type} [[${slugifyWikiSegment(r.to)}]]`) : [];
+	const topicTags = extraction.topics.length > 0 ? extraction.topics.map((t) => `#${t}`).join(" ") : "";
+	const body = [
+		`# ${sourcePath}`,
+		"",
+		"## Summary",
+		extraction.summary,
+		"",
+		entityLinks ? `**Entities:** ${entityLinks}` : "",
+		conceptLinks ? `**Concepts:** ${conceptLinks}` : "",
+		"",
+		relationshipLines.length > 0 ? [
+			"## Connections",
+			...relationshipLines,
+			""
+		].join("\n") : "",
+		"## Key Claims",
+		...extraction.claims.slice(0, 10).map((c) => `- (${(c.confidence * 100).toFixed(0)}%) ${c.text}`),
+		"",
+		topicTags ? `**Topics:** ${topicTags}` : "",
+		"",
+		`*Source: ${sourcePath}*`
+	].filter(Boolean).join("\n");
+	await atomicWrite(absolutePath, renderWikiMarkdown({
+		frontmatter: {
+			pageType: "summary",
+			title: sourcePath,
+			sourceIds: [`source:${slug}`],
+			claims,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		body
+	}));
+	return relativePath;
+}
+async function writeEntityPage(vaultRoot, entity, sourcePath, relationships) {
+	const relativePath = entityPagePath(entity.name);
+	const absolutePath = path.join(vaultRoot, relativePath);
+	const existing = await readFile(absolutePath, "utf8").catch(() => null);
+	const parsed = existing ? parseWikiMarkdown(existing) : null;
+	const sourceLink = `[[${slugifyWikiSegment(sourcePath.replace(/\.[^.]+$/, ""))}]]`;
+	const entitySlug = slugifyWikiSegment(entity.name);
+	const connectionLines = (relationships ?? []).filter((r) => slugifyWikiSegment(r.from) === entitySlug || slugifyWikiSegment(r.to) === entitySlug).map((r) => {
+		return `- [[${slugifyWikiSegment(r.from) === entitySlug ? slugifyWikiSegment(r.to) : slugifyWikiSegment(r.from)}]] (${r.type})`;
+	});
+	if (parsed) {
+		const existingSourceIds = Array.isArray(parsed.frontmatter.sourceIds) ? parsed.frontmatter.sourceIds : [];
+		if (!existingSourceIds.includes(sourceLink)) existingSourceIds.push(sourceLink);
+		const connectionBlock = connectionLines.length > 0 ? `\n**Connections:**\n${connectionLines.join("\n")}\n` : "\n";
+		const mergedBody = `${parsed.body.trimEnd()}
+
+---
+### From: ${sourcePath}
+**Type:** ${entity.type}
+${entity.description}
+${connectionBlock}`;
+		await atomicWrite(absolutePath, renderWikiMarkdown({
+			frontmatter: {
+				...parsed.frontmatter,
+				sourceIds: existingSourceIds,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			body: mergedBody
+		}));
+	} else {
+		const body = [
+			`# ${entity.name}`,
+			"",
+			`**Type:** ${entity.type}`,
+			"",
+			entity.description,
+			"",
+			connectionLines.length > 0 ? `**Connections:**\n${connectionLines.join("\n")}` : "",
+			"",
+			`**Sources:** ${sourceLink}`
+		].filter(Boolean).join("\n");
+		await atomicWrite(absolutePath, renderWikiMarkdown({
+			frontmatter: {
+				pageType: "entity",
+				title: entity.name,
+				sourceIds: [sourceLink],
+				claims: [],
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			body
+		}));
+	}
+	return relativePath;
+}
+async function writeConceptPage(vaultRoot, concept, sourcePath, relationships) {
+	const relativePath = conceptPagePath(concept.name);
+	const absolutePath = path.join(vaultRoot, relativePath);
+	const existing = await readFile(absolutePath, "utf8").catch(() => null);
+	const parsed = existing ? parseWikiMarkdown(existing) : null;
+	const sourceLink = `[[${slugifyWikiSegment(sourcePath.replace(/\.[^.]+$/, ""))}]]`;
+	const conceptSlug = slugifyWikiSegment(concept.name);
+	const connectionLines = (relationships ?? []).filter((r) => slugifyWikiSegment(r.from) === conceptSlug || slugifyWikiSegment(r.to) === conceptSlug).map((r) => {
+		return `- [[${slugifyWikiSegment(r.from) === conceptSlug ? slugifyWikiSegment(r.to) : slugifyWikiSegment(r.from)}]] (${r.type})`;
+	});
+	if (parsed) {
+		const existingSourceIds = Array.isArray(parsed.frontmatter.sourceIds) ? parsed.frontmatter.sourceIds : [];
+		if (!existingSourceIds.includes(sourceLink)) existingSourceIds.push(sourceLink);
+		const conceptConnectionBlock = connectionLines.length > 0 ? `\n**Connections:**\n${connectionLines.join("\n")}\n` : "\n";
+		const mergedBody = `${parsed.body.trimEnd()}
+
+---
+### From: ${sourcePath}
+${concept.description}
+${conceptConnectionBlock}`;
+		await atomicWrite(absolutePath, renderWikiMarkdown({
+			frontmatter: {
+				...parsed.frontmatter,
+				sourceIds: existingSourceIds,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			body: mergedBody
+		}));
+	} else {
+		const relatedLinks = concept.relatedTo?.map((r) => `[[${slugifyWikiSegment(r)}]]`).join(", ");
+		const body = [
+			`# ${concept.name}`,
+			"",
+			concept.description,
+			"",
+			connectionLines.length > 0 ? `**Connections:**\n${connectionLines.join("\n")}` : "",
+			"",
+			`**Sources:** ${sourceLink}`,
+			relatedLinks ? `**Related:** ${relatedLinks}` : ""
+		].filter(Boolean).join("\n");
+		await atomicWrite(absolutePath, renderWikiMarkdown({
+			frontmatter: {
+				pageType: "concept",
+				title: concept.name,
+				sourceIds: [sourceLink],
+				claims: [],
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			},
+			body
+		}));
+	}
+	return relativePath;
+}
+async function writeIndexPage(vaultRoot) {
+	const indexPath = path.join(vaultRoot, "index.md");
+	const dirs = [
+		"summaries",
+		"entities",
+		"concepts"
+	];
+	const byType = /* @__PURE__ */ new Map();
+	for (const dir of dirs) {
+		const dirPath = path.join(vaultRoot, dir);
+		let entries;
+		try {
+			entries = await readdir(dirPath);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.endsWith(".md")) continue;
+			let content;
+			try {
+				content = await readFile(path.join(dirPath, entry), "utf8");
+			} catch {
+				continue;
+			}
+			const parsed = parseWikiMarkdown(content);
+			const title = typeof parsed.frontmatter.title === "string" ? parsed.frontmatter.title : entry.replace(/\.md$/, "");
+			const relativePath = path.join(dir, entry).replace(/\\/g, "/");
+			const arr = byType.get(dir) ?? [];
+			arr.push({
+				path: relativePath,
+				title,
+				type: dir
+			});
+			byType.set(dir, arr);
+		}
+	}
+	const lines = [
+		"# Wiki Index",
+		"",
+		`*Last updated: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}*`,
+		""
+	];
+	for (const dir of dirs) {
+		const typePages = byType.get(dir) ?? [];
+		if (typePages.length === 0) continue;
+		const label = dir.charAt(0).toUpperCase() + dir.slice(1);
+		lines.push(`## ${label} (${typePages.length})`);
+		lines.push("");
+		for (const page of typePages.toSorted((a, b) => a.title.localeCompare(b.title))) {
+			const linkPath = page.path.replace(/\.md$/, "").replace(/\\/g, "/");
+			lines.push(`- [[${linkPath}]] — ${page.title}`);
+		}
+		lines.push("");
+	}
+	await atomicWrite(indexPath, lines.join("\n"));
+}
+//#endregion
+//#region extensions/knowledge-wiki/src/ingest.ts
+async function ingestFile(vaultRoot, source, generateText, _config) {
+	const content = await readFileContent(source.absolutePath);
+	const hash = computeContentHash(content);
+	const stateMap = await loadFileState(vaultRoot);
+	if (!isFileChanged(stateMap, source.relativePath, hash)) return {
+		sourcePath: source.relativePath,
+		summaryPage: "",
+		entityPages: [],
+		conceptPages: [],
+		claimsAdded: 0,
+		skipped: true
+	};
+	const extraction = await extractFromSource(generateText, content, {
+		path: source.relativePath,
+		filename: path.basename(source.relativePath)
+	});
+	if (!extraction.summary && extraction.claims.length === 0) return {
+		sourcePath: source.relativePath,
+		summaryPage: "",
+		entityPages: [],
+		conceptPages: [],
+		claimsAdded: 0,
+		skipped: true
+	};
+	const summaryPage = await writeSummaryPage(vaultRoot, source.relativePath, extraction);
+	const entityPages = [];
+	for (const entity of extraction.entities) try {
+		const pagePath = await writeEntityPage(vaultRoot, entity, source.relativePath, extraction.relationships);
+		entityPages.push(pagePath);
+	} catch {}
+	const conceptPages = [];
+	for (const concept of extraction.concepts) try {
+		const pagePath = await writeConceptPage(vaultRoot, concept, source.relativePath, extraction.relationships);
+		conceptPages.push(pagePath);
+	} catch {}
+	const allPageIds = [
+		summaryPage,
+		...entityPages,
+		...conceptPages
+	];
+	const mutableMap = stateMap;
+	updateEntry(mutableMap, source.relativePath, hash, allPageIds);
+	await saveFileState(vaultRoot, mutableMap);
+	await appendWikiLog(vaultRoot, {
+		type: "ingest",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		sourcePath: source.relativePath,
+		details: [
+			`${extraction.claims.length} claims`,
+			`${extraction.entities.length} entities`,
+			`${extraction.concepts.length} concepts`
+		]
+	});
+	return {
+		sourcePath: source.relativePath,
+		summaryPage,
+		entityPages,
+		conceptPages,
+		claimsAdded: extraction.claims.length,
+		skipped: false
+	};
+}
+async function ingestAll(workspaceDir, vaultRoot, generateText, config) {
+	const scanResult = await scanWorkspace(workspaceDir, config);
+	const ingested = [];
+	const errors = [...scanResult.errors];
+	let skipped = scanResult.skipped;
+	for (const source of scanResult.files) try {
+		const result = await ingestFile(vaultRoot, source, generateText, config);
+		if (result.skipped) skipped++;
+		else ingested.push(result);
+	} catch (err) {
+		errors.push(`ingest failed for ${source.relativePath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (ingested.length > 0) try {
+		await writeIndexPage(vaultRoot);
+	} catch {}
+	return {
+		ingested,
+		skipped,
+		errors
+	};
+}
+async function runWithConcurrency(tasks, limit) {
+	if (tasks.length === 0) return {
+		results: [],
+		errors: []
+	};
+	const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+	const results = Array.from({ length: tasks.length });
+	const errors = [];
+	let next = 0;
+	const workers = Array.from({ length: resolvedLimit }, async () => {
+		while (true) {
+			const index = next;
+			next += 1;
+			if (index >= tasks.length) return;
+			try {
+				results[index] = await tasks[index]();
+			} catch (err) {
+				errors.push(String(err));
+			}
+		}
+	});
+	await Promise.allSettled(workers);
+	return {
+		results,
+		errors
+	};
+}
+async function runWikiIngestAllAgents(params) {
+	if (params.workspaces.length === 0) return [];
+	const { results } = await runWithConcurrency(params.workspaces.map((ws) => async () => {
+		const vaultRoot = params.resolveVaultRoot(ws.workspaceDir);
+		const startTime = Date.now();
+		try {
+			await initializeWikiVault(vaultRoot);
+			const result = await ingestAll(ws.workspaceDir, vaultRoot, params.generateText, params.config);
+			return {
+				agentIds: ws.agentIds,
+				compiled: result.ingested.length,
+				skipped: result.skipped,
+				errors: result.errors.length,
+				durationMs: Date.now() - startTime
+			};
+		} catch {
+			return {
+				agentIds: ws.agentIds,
+				compiled: 0,
+				skipped: 0,
+				errors: 1,
+				durationMs: Date.now() - startTime
+			};
+		}
+	}), params.concurrency);
+	return results;
+}
+//#endregion
+export { inferWikiPageKind as a, scanWorkspace as c, extractWikiLinks as i, ingestFile as n, parseWikiMarkdown as o, runWikiIngestAllAgents as r, initializeWikiVault as s, ingestAll as t };