glimmervoid 0.30.0 → 0.32.0

package/dist/chunks/knowledge-graph-cli-Bjy9_kv5.js

@@ -0,0 +1,1354 @@
+import { r as errorMessage } from "./text-DoirglWV.js";
+import { s as resolvePackageBin } from "./runtime-paths-BPoxENmK.js";
+import { r as execFileSync } from "./child-process-safe-DDELk9XC.js";
+import { n as glimmervoidHomeDir, t as decideConfigPath } from "./config-path-core-DFt-TemS.js";
+import { r as BrowserConfig } from "./config-CZ4H51D0.js";
+import fs, { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import path, { dirname, join, posix, resolve, win32 } from "node:path";
+import { parseArgs } from "node:util";
+import os from "node:os";
+import { z } from "zod";
+import { DatabaseSync } from "node:sqlite";
+//#region knowledge-graph/coherence-delta.ts
+var journalRecordKinds = [
+	"decision",
+	"blocked",
+	"conjecture"
+];
+var openWorkStates = /* @__PURE__ */ new Set([
+	"open",
+	"active",
+	"blocked"
+]);
+var closedTaskStatuses$1 = /* @__PURE__ */ new Set(["done", "dropped"]);
+var openTaskStatuses = /* @__PURE__ */ new Set([
+	"todo",
+	"doing",
+	"waiting"
+]);
+function inferRecordKind(recordId) {
+	if (/^wrk-[0-9a-f]{16}$/.test(recordId)) return "work";
+	if (/^d-[0-9a-f]{8,}$/.test(recordId)) return "decision";
+	return null;
+}
+function findStatusDivergence(trackingStatus, workState) {
+	if (trackingStatus === void 0) return null;
+	if (closedTaskStatuses$1.has(trackingStatus) && openWorkStates.has(workState)) return `kg says ${trackingStatus}, ledger says ${workState}`;
+	if (openTaskStatuses.has(trackingStatus) && workState === "completed") return `ledger says completed, kg still ${trackingStatus}`;
+	if (trackingStatus !== "dropped" && workState === "cancelled") return `ledger says cancelled, kg still ${trackingStatus}`;
+	return null;
+}
+function isAfter(timestamp, since) {
+	return since !== void 0 && timestamp !== null && Date.parse(timestamp) > Date.parse(since);
+}
+function hasDecisionMovedSince(decision, since) {
+	return isAfter(decision.at, since) || isAfter(decision.retractedAt, since);
+}
+function reportWorkRecord(tracked, snapshot, since) {
+	const workOrder = snapshot.workOrders.find((candidate) => candidate.id === tracked.recordId);
+	if (!workOrder) return {
+		tracked,
+		label: tracked.recordId,
+		state: "missing",
+		findings: [{
+			kind: "missing",
+			detail: "not in this repo's work ledger"
+		}],
+		decisions: []
+	};
+	const findings = [];
+	if (snapshot.unverifiedCompletedWorkIds.includes(workOrder.id)) findings.push({
+		kind: "unverified",
+		detail: "completed with no verification on record"
+	});
+	const divergence = tracked.trackingKind === "task" ? findStatusDivergence(tracked.trackingStatus, workOrder.state) : null;
+	if (divergence) findings.push({
+		kind: "status-diverges",
+		detail: divergence
+	});
+	if (isAfter(workOrder.lastEventAt, since)) findings.push({
+		kind: "moved-since",
+		detail: `last event ${workOrder.lastEventAt}`
+	});
+	const decisions = snapshot.decisions.filter((decision) => decision.workId === workOrder.id && (since === void 0 || hasDecisionMovedSince(decision, since)));
+	return {
+		tracked,
+		label: workOrder.objective,
+		state: `${workOrder.state}/${workOrder.readiness}`,
+		findings,
+		decisions
+	};
+}
+function reportDecisionRecord(tracked, snapshot, since) {
+	const decision = snapshot.decisions.find((candidate) => candidate.id === tracked.recordId);
+	if (!decision) return {
+		tracked,
+		label: tracked.recordId,
+		state: "missing",
+		findings: [{
+			kind: "missing",
+			detail: "not in this repo's decision journal"
+		}],
+		decisions: []
+	};
+	const findings = decision.standing === "retracted" ? [{
+		kind: "retracted",
+		detail: "withdrawn in the journal; kg notes relying on it need a look"
+	}] : [];
+	if (isAfter(decision.retractedAt, since)) findings.push({
+		kind: "moved-since",
+		detail: `retracted ${decision.retractedAt}`
+	});
+	if (isAfter(decision.at, since)) findings.push({
+		kind: "moved-since",
+		detail: `decided ${decision.at}`
+	});
+	return {
+		tracked,
+		label: decision.chose,
+		state: `${decision.kind}/${decision.standing}`,
+		findings,
+		decisions: []
+	};
+}
+function buildCoherenceDelta(trackedRecords, snapshotsByRepo, since) {
+	return [...new Set(trackedRecords.map((tracked) => tracked.repo))].toSorted().map((repo) => {
+		const repoRecords = trackedRecords.filter((tracked) => tracked.repo === repo);
+		const snapshot = snapshotsByRepo.get(repo) ?? {
+			isAvailable: false,
+			reason: "not read"
+		};
+		if (!snapshot.isAvailable) return {
+			repo,
+			isAvailable: false,
+			reason: snapshot.reason,
+			records: repoRecords
+		};
+		const records = repoRecords.map((tracked) => tracked.record === "work" ? reportWorkRecord(tracked, snapshot, since) : reportDecisionRecord(tracked, snapshot, since));
+		return {
+			repo,
+			isAvailable: true,
+			heading: snapshot.heading,
+			headingReasons: snapshot.headingReasons,
+			records
+		};
+	});
+}
+//#endregion
+//#region knowledge-graph/graph-schema.ts
+var UNSAFE_TEXT_CHARACTERS = /[\p{Cc}\p{Zl}\p{Zp}\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/gu;
+var INVISIBLE_TEXT_CHARACTERS = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\s]/gu;
+function hasVisibleText(text) {
+	return text.replace(INVISIBLE_TEXT_CHARACTERS, "") !== "";
+}
+function containsUnsafeTextCharacter(text) {
+	return text.match(UNSAFE_TEXT_CHARACTERS) !== null;
+}
+function stripUnsafeTextCharacters(text) {
+	return text.replace(UNSAFE_TEXT_CHARACTERS, "");
+}
+function splitIntoSafeLines(text) {
+	return text.split(/\r\n|[\r\n\u2028\u2029]/).map((line) => line.split("	").map(stripUnsafeTextCharacters).join("	"));
+}
+function listKnownPropertyKeys(schema, kind) {
+	const properties = schema.kinds[kind]?.properties;
+	if (properties === void 0) return null;
+	if (!("shape" in properties) || typeof properties.shape !== "object" || properties.shape === null) return null;
+	return Object.keys(properties.shape);
+}
+function describeUnknownKind(schema, kind) {
+	return `unknown kind "${kind}"; known: ${Object.keys(schema.kinds).join(", ")}`;
+}
+function describeUnknownEdgeType(schema, edgeType) {
+	return `unknown edge type "${edgeType}"; known: ${Object.keys(schema.edges).join(", ")}`;
+}
+function isKindAllowed(allowedKinds, kind) {
+	return allowedKinds === "any" || allowedKinds.includes(kind);
+}
+function describeAllowedKinds(allowedKinds) {
+	return allowedKinds === "any" ? "any kind" : allowedKinds.join(" | ");
+}
+function findEdgeViolation(schema, candidate) {
+	const definition = schema.edges[candidate.edgeType];
+	if (!definition) return describeUnknownEdgeType(schema, candidate.edgeType);
+	if (!isKindAllowed(definition.fromKinds, candidate.fromKind)) return `${candidate.edgeType} cannot start at a ${candidate.fromKind} (${candidate.fromId}); allowed: ${describeAllowedKinds(definition.fromKinds)}`;
+	if (!isKindAllowed(definition.toKinds, candidate.toKind)) return `${candidate.edgeType} cannot point at a ${candidate.toKind} (${candidate.toId}); allowed: ${describeAllowedKinds(definition.toKinds)}`;
+	if (candidate.fromId === candidate.toId) return `${candidate.fromId} cannot ${candidate.edgeType} itself`;
+	if (definition.maxOutgoingPerNode !== void 0 && candidate.existingOutgoingCount >= definition.maxOutgoingPerNode) return `${candidate.fromId} already has ${candidate.existingOutgoingCount} ${candidate.edgeType} edge(s); limit is ${definition.maxOutgoingPerNode}`;
+	if (definition.isAcyclic && candidate.targetReachesSource) return `${candidate.fromId} ${candidate.edgeType} ${candidate.toId} would create a cycle`;
+	return null;
+}
+function parseNodeProperties(schema, kind, rawProperties) {
+	const kindDefinition = schema.kinds[kind];
+	if (!kindDefinition) return { error: describeUnknownKind(schema, kind) };
+	const parsed = kindDefinition.properties.safeParse(rawProperties);
+	if (!parsed.success) return { error: `invalid ${kind} properties:\n${z.prettifyError(parsed.error)}` };
+	return { properties: parsed.data };
+}
+function findCycleNodeIds(edges) {
+	const targetsBySource = /* @__PURE__ */ new Map();
+	for (const edge of edges) targetsBySource.set(edge.fromId, [...targetsBySource.get(edge.fromId) ?? [], edge.toId]);
+	const finishedIds = /* @__PURE__ */ new Set();
+	const onPathIds = /* @__PURE__ */ new Set();
+	const cycleNodeIds = /* @__PURE__ */ new Set();
+	const visit = (nodeId) => {
+		if (finishedIds.has(nodeId)) return;
+		if (onPathIds.has(nodeId)) {
+			cycleNodeIds.add(nodeId);
+			return;
+		}
+		onPathIds.add(nodeId);
+		for (const targetId of targetsBySource.get(nodeId) ?? []) visit(targetId);
+		onPathIds.delete(nodeId);
+		finishedIds.add(nodeId);
+	};
+	for (const sourceId of targetsBySource.keys()) visit(sourceId);
+	return [...cycleNodeIds];
+}
+function findIntegrityViolations(schema, nodes, edges) {
+	const violations = [];
+	const nodesById = new Map(nodes.map((node) => [node.id, node]));
+	for (const node of nodes) {
+		const parsed = parseNodeProperties(schema, node.kind, node.properties);
+		if ("error" in parsed) violations.push(`${node.id}: ${parsed.error}`);
+	}
+	const outgoingCountByTypeAndSource = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const fromNode = nodesById.get(edge.fromId);
+		const toNode = nodesById.get(edge.toId);
+		if (!fromNode || !toNode) {
+			violations.push(`${edge.fromId} ${edge.edgeType} ${edge.toId}: dangling edge`);
+			continue;
+		}
+		const countKey = `${edge.edgeType}\u0000${edge.fromId}`;
+		const existingOutgoingCount = outgoingCountByTypeAndSource.get(countKey) ?? 0;
+		outgoingCountByTypeAndSource.set(countKey, existingOutgoingCount + 1);
+		const violation = findEdgeViolation(schema, {
+			edgeType: edge.edgeType,
+			fromId: edge.fromId,
+			fromKind: fromNode.kind,
+			toId: edge.toId,
+			toKind: toNode.kind,
+			existingOutgoingCount,
+			targetReachesSource: false
+		});
+		if (violation) violations.push(violation);
+	}
+	for (const [edgeType, definition] of Object.entries(schema.edges)) {
+		if (!definition.isAcyclic) continue;
+		const cycleNodeIds = findCycleNodeIds(edges.filter((edge) => edge.edgeType === edgeType));
+		if (cycleNodeIds.length > 0) violations.push(`${edgeType} cycle through ${cycleNodeIds.join(", ")}`);
+	}
+	return violations;
+}
+//#endregion
+//#region knowledge-graph/coherence-source.ts
+var LedgerText = z.string().transform(stripUnsafeTextCharacters);
+var CoherenceRefusal = z.looseObject({ error: LedgerText });
+var WorkInspectOutput = z.looseObject({ work: z.array(z.looseObject({
+	work: LedgerText,
+	state: LedgerText,
+	readiness: LedgerText,
+	opened: z.looseObject({ objective: LedgerText }),
+	last: z.looseObject({ at: LedgerText }).nullable()
+})) });
+var OrientHeading = z.looseObject({
+	action: LedgerText,
+	reasons: z.array(LedgerText)
+});
+var OrientOutput = OrientHeading.extend({ consequences: z.looseObject({ unverifiedCompletedWork: z.array(LedgerText) }) });
+var TrackableJournalKind = z.enum(journalRecordKinds);
+var JournalRow = z.looseObject({
+	id: LedgerText,
+	kind: LedgerText,
+	at: LedgerText,
+	chose: LedgerText.optional(),
+	because: LedgerText.optional(),
+	work: LedgerText.optional(),
+	supersedes: LedgerText.optional()
+});
+var JOURNAL_OPEN_FLAGS = constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0);
+function readRegularFile(filePath, displayName) {
+	if (!lstatSync(filePath).isFile()) throw new Error(`${displayName} is not a regular file`);
+	const fileDescriptor = openSync(filePath, JOURNAL_OPEN_FLAGS);
+	try {
+		if (!fstatSync(fileDescriptor).isFile()) throw new Error(`${displayName} is not a regular file`);
+		return readFileSync(fileDescriptor, "utf8");
+	} finally {
+		closeSync(fileDescriptor);
+	}
+}
+function readCompleteJournalLines(filePath, displayName) {
+	return readRegularFile(filePath, displayName).split("\n").slice(0, -1).filter((line) => line.trim() !== "");
+}
+function findEarliestRetractionAtById(rows) {
+	const retractedAtById = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.kind !== "retraction" || !row.supersedes) continue;
+		const knownAt = retractedAtById.get(row.supersedes);
+		if (knownAt !== void 0 && Date.parse(knownAt) <= Date.parse(row.at)) continue;
+		retractedAtById.set(row.supersedes, row.at);
+	}
+	return retractedAtById;
+}
+function findSettlementById(rows, retractedAtById) {
+	const settlementById = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (!row.supersedes || retractedAtById.has(row.id)) continue;
+		if (row.kind === "resolution") settlementById.set(row.supersedes, "resolved");
+		if (row.kind === "dismissal" && settlementById.get(row.supersedes) !== "resolved") settlementById.set(row.supersedes, "dismissed");
+	}
+	return settlementById;
+}
+function listJournalFiles(journalDirectory, relativeDirectory) {
+	return readdirSync(join(journalDirectory, relativeDirectory), { withFileTypes: true }).flatMap((entry) => {
+		const relativePath = join(relativeDirectory, entry.name);
+		if (entry.name.endsWith(".jsonl")) return [relativePath];
+		if (entry.isSymbolicLink()) throw new Error(`${relativePath} is a symbolic link`);
+		if (entry.isDirectory()) return listJournalFiles(journalDirectory, relativePath);
+		return [];
+	});
+}
+function readDecisionJournal(repo) {
+	const journalDirectory = join(repo, ".coherence", "decisions");
+	const journalDirectoryStats = lstatSync(journalDirectory, { throwIfNoEntry: false });
+	if (journalDirectoryStats === void 0) return [];
+	if (!journalDirectoryStats.isDirectory()) throw new Error(".coherence/decisions is not a directory");
+	const rows = listJournalFiles(journalDirectory, "").flatMap((fileName) => readCompleteJournalLines(join(journalDirectory, fileName), fileName).map((line, index) => {
+		const parsed = JournalRow.safeParse(JSON.parse(line));
+		if (!parsed.success) throw new Error(`unreadable journal row ${fileName}:${index + 1}`);
+		return parsed.data;
+	}));
+	const retractedAtById = findEarliestRetractionAtById(rows);
+	const settlementById = findSettlementById(rows, retractedAtById);
+	const standingOf = (row, isConjecture) => {
+		if (retractedAtById.has(row.id)) return "retracted";
+		if (!isConjecture) return "standing";
+		return settlementById.get(row.id) ?? "open";
+	};
+	return rows.flatMap((row) => {
+		const kind = TrackableJournalKind.safeParse(row.kind);
+		if (!kind.success) return [];
+		return [{
+			id: row.id,
+			kind: kind.data,
+			standing: standingOf(row, kind.data === "conjecture"),
+			chose: row.chose ?? "",
+			because: row.because ?? "",
+			at: row.at,
+			workId: row.work ?? null,
+			retractedAt: retractedAtById.get(row.id) ?? null
+		}];
+	}).toSorted((left, right) => left.at.localeCompare(right.at));
+}
+function describeShapeDrift(commandName, error) {
+	const firstIssue = error.issues[0];
+	if (firstIssue === void 0) return `unexpected ${commandName} output`;
+	return stripUnsafeTextCharacters(`unexpected ${commandName} output at ${firstIssue.path.length === 0 ? "top level" : firstIssue.path.join(".")}: ${firstIssue.message}`);
+}
+function describeOrientFailure(orientJson, error) {
+	const heading = OrientHeading.safeParse(orientJson);
+	if (heading.success && heading.data.action === "refuse") return `orient refused: ${heading.data.reasons.join("; ")}`;
+	return describeShapeDrift("coherence orient", error);
+}
+function describeReadFailure(error) {
+	if (error instanceof Error && "code" in error && error.code === "ENOENT") return "coherence CLI not found";
+	return stripUnsafeTextCharacters(error instanceof Error ? error.message.split("\n")[0] ?? "unknown error" : String(error));
+}
+function readRepoSnapshot(repo, runCoherence) {
+	const runCoherenceJson = (commandArguments) => JSON.parse(runCoherence(repo, commandArguments));
+	if (!existsSync(join(repo, ".coherence"))) return {
+		isAvailable: false,
+		reason: "no .coherence ledger in this repo"
+	};
+	try {
+		const workInspectJson = runCoherenceJson([
+			"work",
+			"inspect",
+			"--json"
+		]);
+		const workRefusal = CoherenceRefusal.safeParse(workInspectJson);
+		if (workRefusal.success) return {
+			isAvailable: false,
+			reason: `work ledger refused: ${workRefusal.data.error}`
+		};
+		const workInspect = WorkInspectOutput.safeParse(workInspectJson);
+		if (!workInspect.success) return {
+			isAvailable: false,
+			reason: describeShapeDrift("coherence work inspect", workInspect.error)
+		};
+		const orientJson = runCoherenceJson(["orient", "--json"]);
+		const orient = OrientOutput.safeParse(orientJson);
+		if (!orient.success) return {
+			isAvailable: false,
+			reason: describeOrientFailure(orientJson, orient.error)
+		};
+		const workOrders = workInspect.data.work.map((entry) => ({
+			id: entry.work,
+			objective: entry.opened.objective,
+			state: entry.state,
+			readiness: entry.readiness,
+			lastEventAt: entry.last?.at ?? null
+		}));
+		return {
+			isAvailable: true,
+			heading: orient.data.action,
+			headingReasons: orient.data.reasons,
+			workOrders,
+			unverifiedCompletedWorkIds: orient.data.consequences.unverifiedCompletedWork,
+			decisions: readDecisionJournal(repo)
+		};
+	} catch (error) {
+		return {
+			isAvailable: false,
+			reason: describeReadFailure(error)
+		};
+	}
+}
+//#endregion
+//#region knowledge-graph/graph-store.ts
+var NodeRow = z.object({
+	id: z.string(),
+	kind: z.string(),
+	title: z.string(),
+	body: z.string(),
+	properties: z.string(),
+	created_at: z.string(),
+	updated_at: z.string()
+});
+var EdgeRow = z.object({
+	edge_type: z.string(),
+	from_id: z.string(),
+	to_id: z.string(),
+	created_at: z.string()
+});
+var MetaRow = z.object({ value: z.string() });
+var ColumnNameRow = z.object({ name: z.string() });
+var CountRow = z.object({ edge_count: z.number() });
+var NumberRow = z.object({ last_number: z.number() });
+var NeighbourRow = z.object({ id: z.string() });
+var SqliteBusyError = z.looseObject({ errcode: z.literal(5) });
+var tableDefinitions = `
+  CREATE TABLE IF NOT EXISTS graph_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+  CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL,
+    title TEXT NOT NULL CHECK (length(trim(title)) > 0),
+    body TEXT NOT NULL DEFAULT '',
+    properties TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(properties)),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS nodes_by_kind ON nodes (kind);
+  CREATE TABLE IF NOT EXISTS edges (
+    edge_type TEXT NOT NULL,
+    from_id TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+    to_id TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (edge_type, from_id, to_id)
+  );
+  CREATE INDEX IF NOT EXISTS edges_by_target ON edges (to_id, edge_type);
+  CREATE TABLE IF NOT EXISTS id_counters (prefix TEXT PRIMARY KEY, last_number INTEGER NOT NULL);
+  CREATE VIRTUAL TABLE IF NOT EXISTS node_search USING fts5 (id UNINDEXED, title, body);
+`;
+function toGraphNode(row) {
+	const parsedRow = NodeRow.parse(row);
+	return {
+		id: parsedRow.id,
+		kind: parsedRow.kind,
+		title: parsedRow.title,
+		body: parsedRow.body,
+		properties: z.record(z.string(), z.unknown()).parse(JSON.parse(parsedRow.properties)),
+		createdAt: parsedRow.created_at,
+		updatedAt: parsedRow.updated_at
+	};
+}
+function toGraphEdge(row) {
+	const parsedRow = EdgeRow.parse(row);
+	return {
+		edgeType: parsedRow.edge_type,
+		fromId: parsedRow.from_id,
+		toId: parsedRow.to_id,
+		createdAt: parsedRow.created_at
+	};
+}
+function toSearchExpression(text) {
+	return text.split(/\s+/).filter((token) => token.length > 0).map((token) => `"${token.replaceAll("\"", "\"\"")}"*`).join(" ");
+}
+function withoutEmptyValues(properties) {
+	return Object.fromEntries(Object.entries(properties).filter(([, value]) => value !== void 0 && value !== ""));
+}
+var BUSY_TIMEOUT_MS = 5e3;
+var JOURNAL_SWITCH_RETRY_MS = 10;
+function normalizeTitle(title) {
+	const trimmedTitle = title.trim();
+	if (!hasVisibleText(trimmedTitle)) throw new Error("title must not be empty");
+	if (containsUnsafeTextCharacter(trimmedTitle)) throw new Error("title must be one line without control or bidi characters");
+	return trimmedTitle;
+}
+function readOwnership(database) {
+	if (!(database.prepare("SELECT 1 AS found FROM sqlite_master WHERE substr(name, 1, 7) <> 'sqlite_' LIMIT 1").get() !== void 0)) return { kind: "fresh" };
+	const metaColumnNames = database.prepare("SELECT name FROM pragma_table_info('graph_meta')").all().map((row) => ColumnNameRow.parse(row).name);
+	if (!metaColumnNames.includes("key") || !metaColumnNames.includes("value")) return { kind: "foreign" };
+	const storedName = MetaRow.safeParse(database.prepare("SELECT value FROM graph_meta WHERE key = 'schema_name'").get());
+	return storedName.success ? {
+		kind: "owned",
+		schemaName: storedName.data.value
+	} : { kind: "foreign" };
+}
+function refuseUnlessClaimable(ownership, databasePath, schema) {
+	if (ownership.kind === "foreign") throw new Error(`${databasePath} is not a knowledge graph database; refusing to claim it`);
+	if (ownership.kind === "owned" && ownership.schemaName !== schema.name) throw new Error(`${databasePath} belongs to the "${ownership.schemaName}" graph, not "${schema.name}"`);
+}
+function runInTransaction(database, work, beginStatement = "BEGIN IMMEDIATE") {
+	if (database.isTransaction) return work();
+	database.exec(beginStatement);
+	try {
+		const value = work();
+		database.exec("COMMIT");
+		return value;
+	} catch (error) {
+		database.exec("ROLLBACK");
+		throw error;
+	}
+}
+function tryEnableWriteAheadLog(database, deadlineMs) {
+	try {
+		database.exec("PRAGMA journal_mode = WAL");
+		return true;
+	} catch (error) {
+		if (SqliteBusyError.safeParse(error).success && Date.now() < deadlineMs) return false;
+		throw error;
+	}
+}
+function enableWriteAheadLog(database) {
+	const deadlineMs = Date.now() + BUSY_TIMEOUT_MS;
+	const retryPause = new Int32Array(new SharedArrayBuffer(4));
+	while (!tryEnableWriteAheadLog(database, deadlineMs)) Atomics.wait(retryPause, 0, 0, JOURNAL_SWITCH_RETRY_MS);
+}
+function claimDatabase(database, databasePath, schema) {
+	refuseUnlessClaimable(readOwnership(database), databasePath, schema);
+	database.exec("PRAGMA foreign_keys = ON");
+	runInTransaction(database, () => {
+		const ownership = readOwnership(database);
+		refuseUnlessClaimable(ownership, databasePath, schema);
+		database.exec(tableDefinitions);
+		if (ownership.kind !== "fresh") return;
+		database.prepare("INSERT INTO graph_meta (key, value) VALUES ('schema_name', ?), ('schema_version', ?)").run(schema.name, String(schema.version));
+	});
+	enableWriteAheadLog(database);
+}
+function openGraphStore(databasePath, schema, currentTimestamp = () => (/* @__PURE__ */ new Date()).toISOString()) {
+	const database = new DatabaseSync(databasePath, { timeout: BUSY_TIMEOUT_MS });
+	try {
+		claimDatabase(database, databasePath, schema);
+	} catch (error) {
+		database.close();
+		throw error;
+	}
+	const transaction = (work) => runInTransaction(database, work);
+	const getNode = (id) => {
+		const row = database.prepare("SELECT * FROM nodes WHERE id = ?").get(id);
+		return row === void 0 ? null : toGraphNode(row);
+	};
+	const requireNode = (id) => {
+		const node = getNode(id);
+		if (!node) throw new Error(`no node with id ${id}`);
+		return node;
+	};
+	const writeSearchEntry = (node) => {
+		database.prepare("DELETE FROM node_search WHERE id = ?").run(node.id);
+		database.prepare("INSERT INTO node_search (id, title, body) VALUES (?, ?, ?)").run(node.id, node.title, node.body);
+	};
+	const claimNextId = (idPrefix) => {
+		const row = database.prepare("INSERT INTO id_counters (prefix, last_number) VALUES (?, 1) ON CONFLICT (prefix) DO UPDATE SET last_number = last_number + 1 RETURNING last_number").get(idPrefix);
+		return `${idPrefix}-${NumberRow.parse(row).last_number}`;
+	};
+	const parsePropertiesOrThrow = (kind, rawProperties) => {
+		const parsed = parseNodeProperties(schema, kind, rawProperties);
+		if ("error" in parsed) throw new Error(parsed.error);
+		return parsed.properties;
+	};
+	const addNode = (kind, title, rawProperties = {}, body = "") => {
+		const properties = parsePropertiesOrThrow(kind, withoutEmptyValues(rawProperties));
+		const normalizedTitle = normalizeTitle(title);
+		const idPrefix = schema.kinds[kind]?.idPrefix ?? kind;
+		return transaction(() => {
+			const timestamp = currentTimestamp();
+			const id = claimNextId(idPrefix);
+			database.prepare("INSERT INTO nodes (id, kind, title, body, properties, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, kind, normalizedTitle, body, JSON.stringify(properties), timestamp, timestamp);
+			const node = requireNode(id);
+			writeSearchEntry(node);
+			return node;
+		});
+	};
+	const updateNode = (id, changes) => {
+		const title = changes.title === void 0 ? void 0 : normalizeTitle(changes.title);
+		return transaction(() => {
+			const existing = requireNode(id);
+			const mergedProperties = withoutEmptyValues({
+				...existing.properties,
+				...changes.properties
+			});
+			const properties = parsePropertiesOrThrow(existing.kind, mergedProperties);
+			database.prepare("UPDATE nodes SET title = ?, body = ?, properties = ?, updated_at = ? WHERE id = ?").run(title ?? existing.title, changes.body ?? existing.body, JSON.stringify(properties), currentTimestamp(), id);
+			const node = requireNode(id);
+			writeSearchEntry(node);
+			return node;
+		});
+	};
+	const removeNode = (id) => {
+		requireNode(id);
+		transaction(() => {
+			database.prepare("DELETE FROM nodes WHERE id = ?").run(id);
+			database.prepare("DELETE FROM node_search WHERE id = ?").run(id);
+		});
+	};
+	const isReachable = (edgeType, startId, targetId) => {
+		return database.prepare(`
+        WITH RECURSIVE reachable (id) AS (
+          SELECT ?
+          UNION
+          SELECT edges.to_id FROM edges JOIN reachable ON edges.from_id = reachable.id WHERE edges.edge_type = ?
+        )
+        SELECT 1 AS found FROM reachable WHERE id = ? LIMIT 1`).get(startId, edgeType, targetId) !== void 0;
+	};
+	const findEdge = (fromId, edgeType, toId) => {
+		const row = database.prepare("SELECT * FROM edges WHERE edge_type = ? AND from_id = ? AND to_id = ?").get(edgeType, fromId, toId);
+		return row === void 0 ? null : toGraphEdge(row);
+	};
+	const link = (fromId, edgeType, toId) => {
+		const fromNode = requireNode(fromId);
+		const toNode = requireNode(toId);
+		return transaction(() => {
+			const existingEdge = findEdge(fromId, edgeType, toId);
+			if (existingEdge) return existingEdge;
+			const countRow = database.prepare("SELECT count(*) AS edge_count FROM edges WHERE edge_type = ? AND from_id = ?").get(edgeType, fromId);
+			const violation = findEdgeViolation(schema, {
+				edgeType,
+				fromId,
+				fromKind: fromNode.kind,
+				toId,
+				toKind: toNode.kind,
+				existingOutgoingCount: CountRow.parse(countRow).edge_count,
+				targetReachesSource: isReachable(edgeType, toId, fromId)
+			});
+			if (violation) throw new Error(violation);
+			const createdAt = currentTimestamp();
+			database.prepare("INSERT INTO edges (edge_type, from_id, to_id, created_at) VALUES (?, ?, ?, ?)").run(edgeType, fromId, toId, createdAt);
+			return {
+				edgeType,
+				fromId,
+				toId,
+				createdAt
+			};
+		});
+	};
+	const unlink = (fromId, edgeType, toId) => Number(database.prepare("DELETE FROM edges WHERE edge_type = ? AND from_id = ? AND to_id = ?").run(edgeType, fromId, toId).changes) > 0;
+	const refuseUnknownFilters = (kind, propertyFilters) => {
+		if (kind !== void 0 && !schema.kinds[kind]) throw new Error(describeUnknownKind(schema, kind));
+		const filterKeys = Object.keys(propertyFilters);
+		if (filterKeys.length === 0) return;
+		const knownKeysPerKind = (kind === void 0 ? Object.keys(schema.kinds) : [kind]).map((kindInScope) => listKnownPropertyKeys(schema, kindInScope));
+		if (knownKeysPerKind.includes(null)) return;
+		const knownKeys = new Set(knownKeysPerKind.flatMap((keys) => keys ?? []));
+		const unknownKey = filterKeys.find((key) => !knownKeys.has(key));
+		if (unknownKey !== void 0) throw new Error(`unknown field "${unknownKey}"${kind === void 0 ? "" : ` for ${kind}`}; known: ${[...knownKeys].join(", ")}`);
+	};
+	const listNodes = (kind, propertyFilters = {}) => {
+		refuseUnknownFilters(kind, propertyFilters);
+		const rows = kind === void 0 ? database.prepare("SELECT * FROM nodes ORDER BY created_at, id").all() : database.prepare("SELECT * FROM nodes WHERE kind = ? ORDER BY created_at, id").all(kind);
+		const filterEntries = Object.entries(propertyFilters);
+		return rows.map(toGraphNode).filter((node) => filterEntries.every(([key, expected]) => String(node.properties[key] ?? "") === expected));
+	};
+	const listEdges = (edgeType) => {
+		return (edgeType === void 0 ? database.prepare("SELECT * FROM edges ORDER BY created_at").all() : database.prepare("SELECT * FROM edges WHERE edge_type = ? ORDER BY created_at").all(edgeType)).map(toGraphEdge);
+	};
+	const outgoingEdges = (id) => database.prepare("SELECT * FROM edges WHERE from_id = ? ORDER BY edge_type, to_id").all(id).map(toGraphEdge);
+	const incomingEdges = (id) => database.prepare("SELECT * FROM edges WHERE to_id = ? ORDER BY edge_type, from_id").all(id).map(toGraphEdge);
+	const walkWithinSnapshot = (startId, edgeType, direction) => {
+		requireNode(startId);
+		if (!schema.edges[edgeType]) throw new Error(describeUnknownEdgeType(schema, edgeType));
+		const neighbourQuery = direction === "outgoing" ? database.prepare("SELECT to_id AS id FROM edges WHERE edge_type = ? AND from_id = ?") : database.prepare("SELECT from_id AS id FROM edges WHERE edge_type = ? AND to_id = ?");
+		const visitedIds = /* @__PURE__ */ new Set([startId]);
+		const steps = [];
+		let frontierIds = [startId];
+		for (let depth = 1; frontierIds.length > 0; depth += 1) {
+			const nextFrontierIds = [];
+			for (const nodeId of frontierIds) for (const row of neighbourQuery.all(edgeType, nodeId)) {
+				const neighbourId = NeighbourRow.parse(row).id;
+				if (visitedIds.has(neighbourId)) continue;
+				visitedIds.add(neighbourId);
+				nextFrontierIds.push(neighbourId);
+			}
+			nextFrontierIds.sort();
+			for (const nodeId of nextFrontierIds) steps.push({
+				node: requireNode(nodeId),
+				depth
+			});
+			frontierIds = nextFrontierIds;
+		}
+		return steps;
+	};
+	const walk = (startId, edgeType, direction) => runInTransaction(database, () => walkWithinSnapshot(startId, edgeType, direction), "BEGIN DEFERRED");
+	const search = (text, limit = 20) => {
+		const expression = toSearchExpression(text);
+		if (expression === "") return [];
+		return database.prepare("SELECT nodes.* FROM node_search JOIN nodes ON nodes.id = node_search.id WHERE node_search MATCH ? ORDER BY rank LIMIT ?").all(expression, limit).map(toGraphNode);
+	};
+	const checkIntegrity = () => findIntegrityViolations(schema, listNodes(), listEdges());
+	return {
+		schema,
+		addNode,
+		updateNode,
+		removeNode,
+		getNode,
+		requireNode,
+		link,
+		unlink,
+		listNodes,
+		listEdges,
+		outgoingEdges,
+		incomingEdges,
+		walk,
+		search,
+		checkIntegrity,
+		transaction,
+		close: () => database.close()
+	};
+}
+//#endregion
+//#region knowledge-graph/personal-schema.ts
+var TaskStatus = z.enum([
+	"todo",
+	"doing",
+	"waiting",
+	"done",
+	"dropped"
+]);
+var ProjectStatus = z.enum([
+	"active",
+	"paused",
+	"done",
+	"archived"
+]);
+var TaskPriority = z.enum([
+	"p0",
+	"p1",
+	"p2",
+	"p3"
+]);
+var AbsoluteRepoPath = z.string().refine((repoPath) => posix.isAbsolute(repoPath) || win32.isAbsolute(repoPath), { message: "repo must be an absolute path" });
+var personalSchema = {
+	name: "personal",
+	version: 1,
+	kinds: {
+		project: {
+			idPrefix: "P",
+			description: "A body of work with an outcome (a work project, a side project)",
+			properties: z.strictObject({
+				status: ProjectStatus.default("active"),
+				area: z.enum(["work", "personal"]).default("work")
+			})
+		},
+		task: {
+			idPrefix: "T",
+			description: "A concrete next action",
+			properties: z.strictObject({
+				status: TaskStatus.default("todo"),
+				priority: TaskPriority.default("p2"),
+				due: z.iso.date().optional()
+			})
+		},
+		note: {
+			idPrefix: "N",
+			description: "Knowledge you want to keep: a fact, a how-to, an insight, a log entry",
+			properties: z.strictObject({ noteType: z.enum([
+				"fact",
+				"howto",
+				"insight",
+				"log"
+			]).default("insight") })
+		},
+		reference: {
+			idPrefix: "R",
+			description: "An external source: article, paper, book, repo, doc, video, talk",
+			properties: z.strictObject({
+				medium: z.enum([
+					"article",
+					"paper",
+					"book",
+					"repo",
+					"doc",
+					"video",
+					"talk"
+				]).default("article"),
+				url: z.url().optional(),
+				author: z.string().min(1).optional()
+			})
+		},
+		question: {
+			idPrefix: "Q",
+			description: "An open research question",
+			properties: z.strictObject({ status: z.enum([
+				"open",
+				"answered",
+				"parked"
+			]).default("open") })
+		},
+		coherence_record: {
+			idPrefix: "C",
+			description: "A pointer to a ticket or decision in a repo's Coherence ledger; the ledger stays the source of truth",
+			properties: z.strictObject({
+				repo: AbsoluteRepoPath,
+				record: z.enum(["work", "decision"]),
+				recordId: z.string()
+			}).refine((pointer) => inferRecordKind(pointer.recordId) === pointer.record, {
+				message: "recordId does not match record kind",
+				path: ["recordId"]
+			})
+		},
+		topic: {
+			idPrefix: "TP",
+			description: "A subject area that cuts across projects",
+			properties: z.strictObject({})
+		}
+	},
+	edges: {
+		part_of: {
+			description: "Belongs to a project",
+			fromKinds: [
+				"task",
+				"note",
+				"reference",
+				"question"
+			],
+			toKinds: ["project"],
+			maxOutgoingPerNode: 1
+		},
+		subtask_of: {
+			description: "Is a step of a larger task",
+			fromKinds: ["task"],
+			toKinds: ["task"],
+			maxOutgoingPerNode: 1,
+			isAcyclic: true
+		},
+		blocks: {
+			description: "Must finish before the target task can start",
+			fromKinds: ["task"],
+			toKinds: ["task"],
+			isAcyclic: true
+		},
+		cites: {
+			description: "Draws on an external source",
+			fromKinds: [
+				"note",
+				"question",
+				"task",
+				"project"
+			],
+			toKinds: ["reference"]
+		},
+		answers: {
+			description: "Resolves a research question",
+			fromKinds: ["note"],
+			toKinds: ["question"]
+		},
+		supersedes: {
+			description: "Replaces an older note",
+			fromKinds: ["note"],
+			toKinds: ["note"],
+			maxOutgoingPerNode: 1,
+			isAcyclic: true
+		},
+		tracked_by: {
+			description: "Is carried out or settled by a record in a Coherence ledger",
+			fromKinds: [
+				"project",
+				"task",
+				"note",
+				"question"
+			],
+			toKinds: ["coherence_record"]
+		},
+		about: {
+			description: "Is about a topic",
+			fromKinds: "any",
+			toKinds: ["topic"]
+		},
+		relates_to: {
+			description: "Loosely related; prefer a specific edge when one fits",
+			fromKinds: "any",
+			toKinds: "any"
+		}
+	}
+};
+var closedTaskStatuses = /* @__PURE__ */ new Set(["done", "dropped"]);
+var actionableTaskStatuses = /* @__PURE__ */ new Set(["todo", "doing"]);
+var priorityRank = {
+	p0: 0,
+	p1: 1,
+	p2: 2,
+	p3: 3
+};
+function isTaskClosed(status) {
+	return typeof status === "string" && closedTaskStatuses.has(status);
+}
+function rankNextActions(candidates) {
+	const isActionable = (candidate) => actionableTaskStatuses.has(candidate.status) && candidate.openBlockerIds.length === 0 && (candidate.projectStatus === void 0 || candidate.projectStatus === "active");
+	const compareCandidates = (left, right) => {
+		const statusOrder = Number(right.status === "doing") - Number(left.status === "doing");
+		if (statusOrder !== 0) return statusOrder;
+		const priorityOrder = (priorityRank[left.priority] ?? 9) - (priorityRank[right.priority] ?? 9);
+		if (priorityOrder !== 0) return priorityOrder;
+		return (left.due ?? "9999-12-31").localeCompare(right.due ?? "9999-12-31");
+	};
+	return candidates.filter(isActionable).toSorted(compareCandidates);
+}
+//#endregion
+//#region knowledge-graph/graph-views.ts
+function readTaskHierarchy(store) {
+	const projectIdByNode = new Map(store.listEdges("part_of").map((edge) => [edge.fromId, edge.toId]));
+	const parentIdByTask = new Map(store.listEdges("subtask_of").map((edge) => [edge.fromId, edge.toId]));
+	const lineageOf = (nodeId) => {
+		const lineage = /* @__PURE__ */ new Set();
+		let currentId = nodeId;
+		while (currentId !== void 0 && !lineage.has(currentId)) {
+			lineage.add(currentId);
+			currentId = parentIdByTask.get(currentId);
+		}
+		return [...lineage];
+	};
+	const projectIdOf = (nodeId) => lineageOf(nodeId).map((lineageId) => projectIdByNode.get(lineageId)).find((projectId) => projectId !== void 0);
+	return {
+		lineageOf,
+		projectIdOf
+	};
+}
+function collectNextActions(store) {
+	const tasks = store.listNodes("task");
+	const nodesById = new Map(store.listNodes().map((node) => [node.id, node]));
+	const openBlockerIdsByTask = /* @__PURE__ */ new Map();
+	for (const edge of store.listEdges("blocks")) {
+		if (isTaskClosed(nodesById.get(edge.fromId)?.properties.status)) continue;
+		openBlockerIdsByTask.set(edge.toId, [...openBlockerIdsByTask.get(edge.toId) ?? [], edge.fromId]);
+	}
+	const hierarchy = readTaskHierarchy(store);
+	return rankNextActions(tasks.map((task) => {
+		const projectId = hierarchy.projectIdOf(task.id);
+		const projectStatus = projectId === void 0 ? void 0 : nodesById.get(projectId)?.properties.status;
+		return {
+			id: task.id,
+			title: task.title,
+			status: String(task.properties.status),
+			priority: String(task.properties.priority),
+			due: typeof task.properties.due === "string" ? task.properties.due : void 0,
+			projectStatus: typeof projectStatus === "string" ? projectStatus : void 0,
+			openBlockerIds: openBlockerIdsByTask.get(task.id) ?? []
+		};
+	}));
+}
+function formatPropertyList(properties) {
+	return Object.entries(properties).map(([key, value]) => `${key}=${stripUnsafeTextCharacters(String(value))}`).join(" ");
+}
+function formatNodeLine(node) {
+	const propertyList = formatPropertyList(node.properties);
+	return `${node.id.padEnd(6)} ${node.kind.padEnd(9)} ${node.title}${propertyList === "" ? "" : `  [${propertyList}]`}`;
+}
+function quoteBody(body) {
+	if (body === "") return "";
+	return splitIntoSafeLines(body).map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+}
+function renderMarkdown(schema, nodes, edges) {
+	const titleById = new Map(nodes.map((node) => [node.id, node.title]));
+	const describeEdge = (edge, perspectiveId) => {
+		const isOutgoing = edge.fromId === perspectiveId;
+		const otherId = isOutgoing ? edge.toId : edge.fromId;
+		return `- ${isOutgoing ? edge.edgeType : `${edge.edgeType} (from)`}: ${otherId} ${titleById.get(otherId) ?? ""}`.trimEnd();
+	};
+	const sections = Object.keys(schema.kinds).map((kind) => {
+		const kindNodes = nodes.filter((node) => node.kind === kind);
+		if (kindNodes.length === 0) return "";
+		const nodeBlocks = kindNodes.map((node) => {
+			const relatedEdges = edges.filter((edge) => edge.fromId === node.id || edge.toId === node.id);
+			return [
+				`### ${node.id} ${node.title}`,
+				formatPropertyList(node.properties),
+				...relatedEdges.map((edge) => describeEdge(edge, node.id)),
+				quoteBody(node.body)
+			].filter((line) => line !== "").join("\n");
+		});
+		return [`## ${kind}`, ...nodeBlocks].join("\n\n");
+	});
+	return `${[`# ${schema.name} graph`, ...sections.filter((section) => section !== "")].join("\n\n")}\n`;
+}
+//#endregion
+//#region knowledge-graph/cli.ts
+var schemasByName = { personal: personalSchema };
+var writeCommandNames = /* @__PURE__ */ new Set([
+	"add",
+	"set",
+	"rm",
+	"link",
+	"unlink",
+	"track"
+]);
+var SinceTimestamp = z.iso.datetime({ offset: true });
+var usage = `glimmervoid kg: a typed, local-first knowledge and task graph (experimental)
+
+  glimmervoid kg schema                              kinds, their fields, and allowed edges
+  glimmervoid kg add <kind> <title> [key=value...]   create a node (--body text)
+  glimmervoid kg set <id> [key=value...]             change fields; title= and body= also work; key= clears
+  glimmervoid kg rm <id>                             delete a node and its edges
+  glimmervoid kg link <from> <edge> <to>             add a typed edge, e.g. kg link T-1 blocks T-2
+  glimmervoid kg unlink <from> <edge> <to>
+  glimmervoid kg show <id>                           a node with every edge in and out
+  glimmervoid kg ls [kind] [key=value...]            list nodes, filtered by fields
+  glimmervoid kg find <text>                         full-text search over titles and bodies
+  glimmervoid kg next                                unblocked todo/doing tasks in active projects, ranked
+  glimmervoid kg chain <id> [edge] [--incoming]      walk an edge transitively; bare "kg chain T-3" lists everything blocking T-3
+  glimmervoid kg check                               re-validate every node and edge against the schema
+  glimmervoid kg export                              the whole graph as markdown
+  glimmervoid kg track <id> <repo> <recordId>        point a kg node at a Coherence ticket (wrk-...) or journal record (d-...)
+  glimmervoid kg delta [id] [--since <iso time>]     what the tracked Coherence records did, and where kg and the ledger disagree
+
+  --graph <name>   which schema (default personal)    --db <path>   database file (default <glimmervoid home>/knowledge-graph/<graph>.sqlite)
+  --json           machine-readable output`;
+function splitAssignments(tokens) {
+	const assignments = {};
+	for (const token of tokens) {
+		const separatorIndex = token.indexOf("=");
+		if (separatorIndex <= 0) throw new Error(`expected key=value, got "${token}"`);
+		assignments[token.slice(0, separatorIndex)] = token.slice(separatorIndex + 1);
+	}
+	return assignments;
+}
+function requirePositional(positionals, index, name) {
+	const value = positionals[index];
+	if (value === void 0) throw new Error(`missing <${name}>\n\n${usage}`);
+	return value;
+}
+function readEdgeArguments(positionals) {
+	return {
+		fromId: requirePositional(positionals, 1, "from"),
+		edgeType: requirePositional(positionals, 2, "edge"),
+		toId: requirePositional(positionals, 3, "to")
+	};
+}
+function collectTrackedRecords(store, scopeNodeId) {
+	const nodesById = new Map(store.listNodes().map((node) => [node.id, node]));
+	const hierarchy = readTaskHierarchy(store);
+	const isInScope = (nodeId) => scopeNodeId === void 0 || hierarchy.lineageOf(nodeId).includes(scopeNodeId) || hierarchy.projectIdOf(nodeId) === scopeNodeId;
+	return store.listEdges("tracked_by").filter((edge) => isInScope(edge.fromId)).flatMap((edge) => {
+		const trackingNode = nodesById.get(edge.fromId);
+		const pointer = nodesById.get(edge.toId);
+		if (!trackingNode || !pointer) return [];
+		const recordId = String(pointer.properties.recordId);
+		const record = inferRecordKind(recordId);
+		if (record === null) return [];
+		const trackingStatus = trackingNode.properties.status;
+		return [{
+			trackingNodeId: trackingNode.id,
+			trackingKind: trackingNode.kind,
+			trackingStatus: typeof trackingStatus === "string" ? trackingStatus : void 0,
+			recordNodeId: pointer.id,
+			repo: String(pointer.properties.repo),
+			record,
+			recordId
+		}];
+	});
+}
+function renderRepoReport(report) {
+	const repoLabel = stripUnsafeTextCharacters(report.repo);
+	if (!report.isAvailable) {
+		const recordLines = report.records.map((tracked) => `  ${tracked.trackingNodeId} -> ${tracked.recordNodeId} ${tracked.recordId}  (not checked)`);
+		return [`${repoLabel}  unavailable: ${report.reason}`, ...recordLines].join("\n");
+	}
+	const recordBlocks = report.records.map((recordReport) => [
+		`  ${recordReport.tracked.trackingNodeId} -> ${recordReport.tracked.recordNodeId} ${recordReport.tracked.record.padEnd(8)} ${recordReport.state.padEnd(16)} ${recordReport.label}`,
+		...recordReport.findings.map((finding) => `       ! ${finding.kind}: ${finding.detail}`),
+		...recordReport.decisions.map((decision) => `       ${decision.kind} ${decision.id} (${decision.standing}) ${decision.chose}`)
+	].join("\n"));
+	return [`${repoLabel}  heading: ${report.heading}${report.headingReasons.length === 0 ? "" : ` (${report.headingReasons.join("; ")})`}`, ...recordBlocks].join("\n");
+}
+function print(context, jsonValue, text) {
+	context.writeOutput(`${context.isJson ? JSON.stringify(jsonValue, null, 2) : text}\n`);
+	return 0;
+}
+function describeSchema(schema) {
+	const kindLines = Object.entries(schema.kinds).map(([kind, definition]) => {
+		const shape = (listKnownPropertyKeys(schema, kind) ?? []).join(", ");
+		return `  ${kind} (${definition.idPrefix}-n): ${definition.description}${shape === "" ? "" : `\n      fields: ${shape}`}`;
+	});
+	const edgeLines = Object.entries(schema.edges).map(([edgeType, definition]) => {
+		const limits = [definition.maxOutgoingPerNode === void 0 ? "" : `max ${definition.maxOutgoingPerNode}`, definition.isAcyclic ? "acyclic" : ""].filter((limit) => limit !== "").join(", ");
+		return `  ${edgeType}: ${describeAllowedKinds(definition.fromKinds)} -> ${describeAllowedKinds(definition.toKinds)}${limits === "" ? "" : ` (${limits})`}  ${definition.description}`;
+	});
+	return [
+		`graph "${schema.name}" v${schema.version}`,
+		"kinds:",
+		...kindLines,
+		"edges:",
+		...edgeLines
+	].join("\n");
+}
+var commands = {
+	schema: (context) => print(context, context.store.schema, describeSchema(context.store.schema)),
+	add: (context) => {
+		const kind = requirePositional(context.positionals, 1, "kind");
+		const title = requirePositional(context.positionals, 2, "title");
+		const node = context.store.addNode(kind, title, splitAssignments(context.positionals.slice(3)), context.body ?? "");
+		print(context, node, formatNodeLine(node));
+	},
+	set: (context) => {
+		const id = requirePositional(context.positionals, 1, "id");
+		const { title, body, ...properties } = splitAssignments(context.positionals.slice(2));
+		const node = context.store.updateNode(id, {
+			title,
+			body: context.body ?? body,
+			properties
+		});
+		print(context, node, formatNodeLine(node));
+	},
+	rm: (context) => {
+		const id = requirePositional(context.positionals, 1, "id");
+		context.store.removeNode(id);
+		print(context, { removed: id }, `removed ${id}`);
+	},
+	link: (context) => {
+		const { fromId, edgeType, toId } = readEdgeArguments(context.positionals);
+		const edge = context.store.link(fromId, edgeType, toId);
+		print(context, edge, `${edge.fromId} ${edge.edgeType} ${edge.toId}`);
+	},
+	unlink: (context) => {
+		const { fromId, edgeType, toId } = readEdgeArguments(context.positionals);
+		const wasRemoved = context.store.unlink(fromId, edgeType, toId);
+		print(context, { removed: wasRemoved }, wasRemoved ? "unlinked" : "no such edge");
+	},
+	show: (context) => {
+		const node = context.store.requireNode(requirePositional(context.positionals, 1, "id"));
+		const outgoing = context.store.outgoingEdges(node.id);
+		const incoming = context.store.incomingEdges(node.id);
+		const titleOf = (id) => context.store.getNode(id)?.title ?? "?";
+		const lines = [
+			formatNodeLine(node),
+			...outgoing.map((edge) => `  -> ${edge.edgeType} ${edge.toId} ${titleOf(edge.toId)}`),
+			...incoming.map((edge) => `  <- ${edge.edgeType} ${edge.fromId} ${titleOf(edge.fromId)}`),
+			node.body === "" ? "" : `\n${splitIntoSafeLines(node.body).join("\n")}`
+		];
+		print(context, {
+			node,
+			outgoing,
+			incoming
+		}, lines.filter((line) => line !== "").join("\n"));
+	},
+	ls: (context) => {
+		const kind = context.positionals[1]?.includes("=") ? void 0 : context.positionals[1];
+		const filterTokens = context.positionals.slice(kind === void 0 ? 1 : 2);
+		const nodes = context.store.listNodes(kind, splitAssignments(filterTokens));
+		print(context, nodes, nodes.map(formatNodeLine).join("\n") || "(none)");
+	},
+	find: (context) => {
+		const nodes = context.store.search(context.positionals.slice(1).join(" "));
+		print(context, nodes, nodes.map(formatNodeLine).join("\n") || "(no matches)");
+	},
+	next: (context) => {
+		const nextActions = collectNextActions(context.store);
+		print(context, nextActions, nextActions.map((action) => `${action.id.padEnd(6)} ${action.priority} ${action.status.padEnd(5)} ${action.title}${action.due === void 0 ? "" : `  due ${action.due}`}`).join("\n") || "(nothing actionable)");
+	},
+	chain: (context) => {
+		const id = requirePositional(context.positionals, 1, "id");
+		const edgeType = context.positionals[2] ?? "blocks";
+		const steps = context.store.walk(id, edgeType, context.isIncoming || context.positionals[2] === void 0 ? "incoming" : "outgoing");
+		print(context, steps, steps.map((step) => `${"  ".repeat(step.depth - 1)}${formatNodeLine(step.node)}`).join("\n") || "(empty)");
+	},
+	check: (context) => {
+		const violations = context.store.checkIntegrity();
+		print(context, violations, violations.join("\n") || "ok: every node and edge matches the schema");
+		return violations.length > 0 ? 1 : 0;
+	},
+	track: (context) => {
+		const trackingNode = context.store.requireNode(requirePositional(context.positionals, 1, "id"));
+		const repo = realpathSync(resolve(requirePositional(context.positionals, 2, "repo")));
+		const recordId = requirePositional(context.positionals, 3, "recordId");
+		const record = inferRecordKind(recordId);
+		if (record === null) throw new Error(`"${recordId}" is neither a ticket id (wrk-...) nor a decision id (d-...)`);
+		const snapshot = readRepoSnapshot(repo, context.runCoherence);
+		if (!snapshot.isAvailable) throw new Error(`cannot verify ${recordId}: ${snapshot.reason}`);
+		const label = record === "work" ? snapshot.workOrders.find((workOrder) => workOrder.id === recordId)?.objective : snapshot.decisions.find((decision) => decision.id === recordId)?.chose;
+		if (label === void 0) throw new Error(`${recordId} is not in the Coherence ledger at ${repo}`);
+		const { pointer, edge } = context.store.transaction(() => {
+			const trackedPointer = context.store.listNodes("coherence_record", {
+				repo,
+				recordId
+			})[0] ?? context.store.addNode("coherence_record", label, {
+				repo,
+				record,
+				recordId
+			});
+			return {
+				pointer: trackedPointer,
+				edge: context.store.link(trackingNode.id, "tracked_by", trackedPointer.id)
+			};
+		});
+		print(context, {
+			pointer,
+			edge
+		}, `${trackingNode.id} tracked_by ${pointer.id} (${record} ${recordId}: ${label})`);
+	},
+	delta: (context) => {
+		const scopeNodeId = context.positionals[1];
+		if (scopeNodeId !== void 0) context.store.requireNode(scopeNodeId);
+		const trackedRecords = collectTrackedRecords(context.store, scopeNodeId);
+		const repos = [...new Set(trackedRecords.map((tracked) => tracked.repo))];
+		const reports = buildCoherenceDelta(trackedRecords, new Map(repos.map((repo) => [repo, readRepoSnapshot(repo, context.runCoherence)])), context.since);
+		print(context, reports, reports.map(renderRepoReport).join("\n\n") || "(nothing tracked; use glimmervoid kg track)");
+	},
+	export: (context) => {
+		context.writeOutput(renderMarkdown(context.store.schema, context.store.listNodes(), context.store.listEdges()));
+	}
+};
+function resolveDatabasePath(requestedPath, commandName, defaultPath) {
+	if (requestedPath === void 0) return defaultPath;
+	if (requestedPath.trim() === "") throw new Error("--db needs a database file path");
+	if (writeCommandNames.has(commandName) || existsSync(requestedPath)) return requestedPath;
+	throw new Error(`no knowledge graph database at ${requestedPath}; check --db, or create it with a write such as kg add`);
+}
+function runCommandLine(commandArguments, dependencies) {
+	const { values, positionals } = parseArgs({
+		args: commandArguments,
+		allowPositionals: true,
+		options: {
+			graph: {
+				type: "string",
+				default: "personal"
+			},
+			db: { type: "string" },
+			body: { type: "string" },
+			since: { type: "string" },
+			incoming: {
+				type: "boolean",
+				default: false
+			},
+			json: {
+				type: "boolean",
+				default: false
+			},
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		}
+	});
+	const commandName = positionals[0];
+	const command = commandName === void 0 ? void 0 : commands[commandName];
+	if (values.help || commandName === void 0 || command === void 0) {
+		dependencies.writeOutput(`${usage}\n`);
+		return values.help ? 0 : 1;
+	}
+	const schema = schemasByName[values.graph];
+	if (!schema) throw new Error(`unknown graph "${values.graph}"; known: ${Object.keys(schemasByName).join(", ")}`);
+	if (values.since !== void 0 && !SinceTimestamp.safeParse(values.since).success) throw new Error(`--since needs an ISO 8601 timestamp with Z or an offset, e.g. 2026-10-09T09:00:00Z; got "${values.since}"`);
+	const databasePath = resolveDatabasePath(values.db, commandName, join(dependencies.defaultDatabaseDirectory, `${schema.name}.sqlite`));
+	mkdirSync(dirname(databasePath), { recursive: true });
+	const store = openGraphStore(databasePath, schema);
+	try {
+		return command({
+			store,
+			positionals,
+			body: values.body,
+			since: values.since,
+			isIncoming: values.incoming,
+			isJson: values.json,
+			runCoherence: dependencies.runCoherence,
+			writeOutput: dependencies.writeOutput
+		}) ?? 0;
+	} finally {
+		store.close();
+	}
+}
+function runKnowledgeGraphCli(commandArguments, dependencies) {
+	try {
+		return runCommandLine(commandArguments, dependencies);
+	} catch (error) {
+		dependencies.writeError(`kg: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 1;
+	}
+}
+//#endregion
+//#region server/knowledge-graph-cli.ts
+var COHERENCE_TIMEOUT_MS = 3e4;
+var COHERENCE_MAX_BUFFER_BYTES = 16777216;
+var CoherenceRefusalExit = z.looseObject({
+	status: z.literal(2),
+	stdout: z.string().min(1)
+});
+var KnowledgeGraphGate = z.looseObject({ knowledgeGraph: BrowserConfig.shape.knowledgeGraph });
+var KNOWLEDGE_GRAPH_DISABLED_MESSAGE = "glimmervoid kg is experimental and off. Turn on Settings > Lanes > Knowledge graph, or set knowledgeGraph.enabled in config.json.";
+function decideKnowledgeGraphGate(configPath) {
+	if (!configPath) return {
+		isEnabled: false,
+		loadError: null
+	};
+	try {
+		const parsed = KnowledgeGraphGate.safeParse(JSON.parse(fs.readFileSync(configPath, "utf8")));
+		return {
+			isEnabled: parsed.success && parsed.data.knowledgeGraph?.enabled === true,
+			loadError: null
+		};
+	} catch (error) {
+		return {
+			isEnabled: false,
+			loadError: `Could not load ${configPath}: ${errorMessage(error)}`
+		};
+	}
+}
+function runBundledCoherence(repo, commandArguments) {
+	const coherenceCliPath = resolvePackageBin("@danilocampos/coherence", "coherence");
+	if (!coherenceCliPath) throw new Error("Could not resolve the coherence CLI");
+	try {
+		return execFileSync(process.execPath, [coherenceCliPath, ...commandArguments], {
+			cwd: repo,
+			env: {
+				...process.env,
+				GIT_OPTIONAL_LOCKS: "0"
+			},
+			encoding: "utf8",
+			timeout: COHERENCE_TIMEOUT_MS,
+			maxBuffer: COHERENCE_MAX_BUFFER_BYTES,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+	} catch (error) {
+		const refusalExit = CoherenceRefusalExit.safeParse(error);
+		if (!refusalExit.success) throw error;
+		return refusalExit.data.stdout;
+	}
+}
+function runKnowledgeGraphCommand(commandArguments) {
+	const homeDirectory = glimmervoidHomeDir(os.homedir(), process.env);
+	const gate = decideKnowledgeGraphGate(decideConfigPath({
+		env: process.env,
+		homeDir: homeDirectory
+	}, (candidate) => fs.existsSync(candidate)).path);
+	if (gate.loadError) {
+		console.error(`kg: ${gate.loadError}`);
+		return 1;
+	}
+	if (!gate.isEnabled) {
+		console.error(KNOWLEDGE_GRAPH_DISABLED_MESSAGE);
+		return 1;
+	}
+	return runKnowledgeGraphCli(commandArguments, {
+		defaultDatabaseDirectory: path.join(homeDirectory, "knowledge-graph"),
+		runCoherence: runBundledCoherence,
+		writeOutput: (text) => process.stdout.write(text),
+		writeError: (text) => process.stderr.write(text)
+	});
+}
+//#endregion
+export { runKnowledgeGraphCommand };