@danypops/papyrus 0.13.6 → 0.15.0

package/src/id-migration.ts

@@ -23,9 +23,7 @@
  * replaces old ids wherever they appear inside a known set of free-text/JSON columns (title,
  * body, extra, and the two Task-event text fields) — this is how a prose cross-reference like
  * "see task some-old-id for the parent epic" keeps pointing at the right artifact after its id
- * changes. Discourse post JSON payloads (content_json/command_json/references_json) are
- * explicitly NOT scanned — that is Discourse-internal structure this tool does not have enough
- * context on yet, tracked as a known limitation rather than guessed at.
+ * changes.
  */
 import type { Db } from "./db.ts";
 import { inTransaction } from "./db.ts";
@@ -56,8 +54,6 @@ const FK_COLUMNS: ReadonlyArray<{ table: string; column: string }> = [
 	{ table: "task_events", column: "task_id" },
 	{ table: "task_scopes", column: "task_id" },
 	{ table: "task_views", column: "root_task_id" },
-	{ table: "discourse_threads", column: "artifact_id" },
-	{ table: "discourse_posts", column: "artifact_id" },
 	{ table: "artifact_events", column: "artifact_id" },
 	{ table: "artifact_events", column: "related_id" },
 ];

package/src/log-service.ts

@@ -0,0 +1,58 @@
+import { randomUUID } from "node:crypto";
+import {
+	boundMessage,
+	LOG_QUERY_MAX_ENTRIES,
+	LOG_RETENTION_MAX_ENTRIES_PER_SOURCE,
+	meetsLevel,
+	validateAppendLogEntryCommand,
+	type AppendLogEntryCommand,
+	type AppendLogEntryResult,
+	type LogEntryPage,
+	type LogQuery,
+} from "./domain/log-entry.ts";
+import type { LogStore } from "./ports/log-store.ts";
+
+export class Logs {
+	constructor(private readonly store: LogStore) {}
+
+	append(command: AppendLogEntryCommand): AppendLogEntryResult {
+		validateAppendLogEntryCommand(command);
+		this.store.ensureSource(command.sourceId, command.sourceLabel ?? command.sourceId, command.projectRoot ?? null);
+		const existing = this.store.findEntryByOperationId(command.sourceId, command.operationId);
+		if (existing) return { entry: existing, replayed: true };
+
+		const { message, truncated } = boundMessage(command.message);
+		const entry = {
+			id: randomUUID(),
+			sourceId: command.sourceId,
+			occurredAt: command.occurredAt ?? new Date().toISOString(),
+			level: command.level,
+			message,
+			truncated,
+			fields: command.fields ?? {},
+			operationId: command.operationId,
+			sessionId: command.sessionId,
+		};
+		this.store.insertEntry(entry);
+		this.store.trimSource(command.sourceId, LOG_RETENTION_MAX_ENTRIES_PER_SOURCE);
+		return { entry, replayed: false };
+	}
+
+	/**
+	 * `since` given: this is a live-tail/polling cursor -- return the OLDEST entries in the
+	 * window so a caller can advance its cursor without skipping any, at the cost of not yet
+	 * seeing the very latest (call again with a later `since` to keep catching up).
+	 * `since` omitted: this is a post-mortem browse -- return the MOST RECENT entries,
+	 * matching `tail -n`'s familiar behavior.
+	 */
+	query(query: LogQuery): LogEntryPage {
+		const limit = Math.min(query.limit ?? LOG_QUERY_MAX_ENTRIES, LOG_QUERY_MAX_ENTRIES);
+		const matching = this.store.entriesForSource(query.sourceId)
+			.filter((entry) => query.since === undefined || entry.occurredAt > query.since)
+			.filter((entry) => query.level === undefined || meetsLevel(entry.level, query.level));
+
+		if (matching.length <= limit) return { entries: matching, truncated: false };
+		const windowed = query.since !== undefined ? matching.slice(0, limit) : matching.slice(matching.length - limit);
+		return { entries: windowed, truncated: true };
+	}
+}

package/src/modules/logs.ts

@@ -0,0 +1,75 @@
+/**
+ * modules/logs.ts — the `log` domain as a registered Papyrus-native module.
+ *
+ * Deliberately self-contained: does not import artifact/task/rule/skill infrastructure --
+ * logs never touch the Artifact graph directly (see src/domain/log-entry.ts's own module
+ * comment on why `log` is not an Artifact kind).
+ */
+import type { JsonValue, LogLevel } from "../domain/log-entry.ts";
+import type { OperationDefinition } from "../module-registry.ts";
+import type { Logs } from "../log-service.ts";
+
+const MODULE_ID = "logs";
+
+type OperationInput = Record<string, unknown>;
+
+function string(input: OperationInput, key: string): string {
+	const value = input[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`${key} is required`);
+	return value;
+}
+
+function optionalString(input: OperationInput, key: string): string | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "string") throw new Error(`${key} must be a string`);
+	return value;
+}
+
+function optionalNumber(input: OperationInput, key: string): number | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${key} must be a number`);
+	return value;
+}
+
+function isJsonValue(value: unknown): value is JsonValue {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+		|| Array.isArray(value) || (typeof value === "object");
+}
+
+function optionalFields(input: OperationInput, key: string): JsonValue | undefined {
+	const value = input[key];
+	if (value === undefined) return undefined;
+	if (!isJsonValue(value)) throw new Error(`${key} must be JSON-serializable`);
+	return value;
+}
+
+/** This module's own operation names, the single source of truth src/service.ts's EXPECTED_OPERATION_NAMES spreads in rather than re-listing by hand. */
+export const LOGS_OPERATION_NAMES = ["logs.append", "logs.query"] as const;
+
+/** Registers every logs.* operation against one Logs instance. */
+export function logsOperations(logs: Logs): OperationDefinition[] {
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name, moduleId: MODULE_ID, execute,
+	});
+	return [
+		define("logs.append", (input: OperationInput) => logs.append({
+			sourceId: string(input, "source_id"),
+			sourceLabel: optionalString(input, "source_label"),
+			projectRoot: optionalString(input, "project_root") ?? null,
+			level: string(input, "level") as LogLevel,
+			message: string(input, "message"),
+			fields: optionalFields(input, "fields"),
+			operationId: string(input, "operation_id"),
+			sessionId: optionalString(input, "session_id"),
+			occurredAt: optionalString(input, "occurred_at"),
+		})),
+		define("logs.query", (input: OperationInput) => logs.query({
+			sourceId: string(input, "source_id"),
+			since: optionalString(input, "since"),
+			level: optionalString(input, "level") as LogLevel | undefined,
+			limit: optionalNumber(input, "limit"),
+		})),
+	];
+}

package/src/ports/log-store.ts

@@ -0,0 +1,17 @@
+import type { LogEntry, LogSource } from "../domain/log-entry.ts";
+
+/**
+ * Persistence port for the `log` domain. Deliberately minimal, matching
+ * ConversationJournalStore's own split: this is dumb storage (idempotency-key lookup,
+ * insert, bounded-at-the-service-layer reads) plus one operation the store must own because
+ * only it knows real row counts -- retention trimming.
+ */
+export interface LogStore {
+	ensureSource(sourceId: string, label: string, projectRoot: string | null): LogSource;
+	findEntryByOperationId(sourceId: string, operationId: string): LogEntry | undefined;
+	insertEntry(entry: LogEntry): void;
+	/** All entries for one source, chronological (oldest first), unbounded at the store layer -- the service applies query bounds/filters. */
+	entriesForSource(sourceId: string): readonly LogEntry[];
+	/** Deletes the oldest entries for a source beyond `maxEntries`, returning how many were removed -- retention enforcement, not a general delete capability. */
+	trimSource(sourceId: string, maxEntries: number): number;
+}

package/src/service.ts

@@ -3,14 +3,12 @@ import { VERSION } from "./version.ts";
 import { migrateDb, openDb, schemaVersion } from "./db.ts";
 import { SQLiteArtifactStore } from "./adapters/sqlite-artifact-store.ts";
 import { SQLiteGateRunner } from "./adapters/sqlite-gate-runner.ts";
-import { SQLiteDiscourseStore } from "./adapters/sqlite-discourse-store.ts";
 import { SQLiteArtifactScopeStore } from "./adapters/sqlite-artifact-scope-store.ts";
 import { SQLiteGraphProjectionStore } from "./adapters/sqlite-graph-projection-store.ts";
 import { SQLiteTaskFocusStore } from "./adapters/sqlite-task-focus-store.ts";
 import { SQLiteTaskEventStore } from "./adapters/sqlite-task-event-store.ts";
 import { SQLiteTaskScopeStore } from "./adapters/sqlite-task-scope-store.ts";
 import type { CreateArtifactInput } from "./domain/artifact.ts";
-import { DISCOURSE_RELATIONS, isDiscourseSubtype } from "./domain/discourse-store.ts";
 import { AuthorityRegistry, AuthorizedArtifactWriter, type AuthorityClaim } from "./authority-registry.ts";
 import type { TaskEventContext } from "./domain/task-event.ts";
 import type { TaskViewMode } from "./domain/task-scope.ts";
@@ -24,9 +22,12 @@ import {
 	listInjectableRules,
 } from "./domain-services.ts";
 import { Notes, NOTE_SUBTYPE } from "./note-service.ts";
+import { Logs } from "./log-service.ts";
+import { SQLiteLogStore } from "./adapters/sqlite-log-store.ts";
 import { OperationRegistry } from "./module-registry.ts";
 import { docsOperations, DOCS_OPERATION_NAMES } from "./modules/docs.ts";
 import { graphProjectionOperations, GRAPH_PROJECTION_OPERATION_NAMES } from "./modules/graph-projection.ts";
+import { logsOperations, LOGS_OPERATION_NAMES } from "./modules/logs.ts";
 import { notesOperations, NOTES_OPERATION_NAMES } from "./modules/notes.ts";
 import { rulesOperations, RULES_OPERATION_NAMES } from "./modules/rules.ts";
 import { skillsOperations, SKILLS_OPERATION_NAMES } from "./modules/skills.ts";
@@ -38,12 +39,13 @@ import { tasksOperations, TASKS_OPERATION_NAMES } from "./modules/tasks.ts";
  * no domain owns creation/linking/traversal for every kind, the same way system.migrate
  * has no owning module) and two permanent composition-root exceptions (rules.injectable
  * needs tasks.active(); skills.instantiate branches into tasks.create()) -- see
- * src/modules/rules.ts and src/modules/skills.ts's module comments. discourse.store's
- * eventual home depends on the still-open Discourse projection-target decision, not on
- * module extraction.
+ * src/modules/rules.ts and src/modules/skills.ts's module comments. Discourse's own
+ * Papyrus-embedded storage (discourse.store) was removed entirely -- zero real callers
+ * were ever confirmed against it; Discourse's real home is the standalone
+ * @danypops/discourse package plus host adapters.
  */
 const COMPOSITION_ROOT_OPERATION_NAMES = [
-	"system.migrate", "discourse.store", "artifact.create", "artifact.query", "artifact.show",
+	"system.migrate", "artifact.create", "artifact.query", "artifact.show",
 	"graph.link", "graph.unlink", "graph.tree", "graph.status", "graph.history", "gates.run",
 	"rules.injectable", "skills.instantiate",
 ] as const;
@@ -65,6 +67,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	...RULES_OPERATION_NAMES,
 	...SKILLS_OPERATION_NAMES,
 	...GRAPH_PROJECTION_OPERATION_NAMES,
+	...LOGS_OPERATION_NAMES,
 ] as const;
 
 export type OperationName = typeof EXPECTED_OPERATION_NAMES[number];
@@ -125,13 +128,6 @@ function templateSubtype(artifacts: ArtifactStore, templateId: string | undefine
  */
 const GENERIC_CALLER = "generic";
 
-const discourseAuthorityClaim: AuthorityClaim = {
-	owner: "discourse",
-	matchesArtifact: (_kind, subtype) => isDiscourseSubtype(subtype),
-	matchesRelation: (relation) => DISCOURSE_RELATIONS.has(relation),
-	denyMessage: (action) => action === "link" ? "forum-owned Context Mesh links require discourse.store" : "forum-owned Context Mesh Docs require discourse.store",
-};
-
 const notesAuthorityClaim: AuthorityClaim = {
 	owner: "notes",
 	matchesArtifact: (kind, subtype) => kind === "doc" && subtype === NOTE_SUBTYPE,
@@ -154,7 +150,7 @@ const tasksAuthorityClaim: AuthorityClaim = {
 
 function createAuthorityRegistry(): AuthorityRegistry {
 	const authority = new AuthorityRegistry();
-	authority.claimAll([discourseAuthorityClaim, notesAuthorityClaim, tasksAuthorityClaim]);
+	authority.claimAll([notesAuthorityClaim, tasksAuthorityClaim]);
 	return authority;
 }
 
@@ -178,7 +174,6 @@ function handlers(
 	gates: GateRunner,
 	tasks: Tasks,
 	notes: Notes,
-	discourse: SQLiteDiscourseStore,
 	events: TaskEventStore,
 	scopes: TaskScopeStore,
 	migrate: () => unknown,
@@ -215,7 +210,6 @@ function handlers(
 	});
 	return {
 		"system.migrate": () => migrate(),
-		"discourse.store": (input) => discourse.execute(input),
 		"artifact.create": (input) => {
 			const normalized = normalizeCreateInput(input);
 			authority.requireArtifactAllowed(normalized.kind, normalized.subtype ?? templateSubtype(artifacts, normalized.templateId), "create", GENERIC_CALLER);
@@ -353,10 +347,9 @@ function handlers(
 		"skills.instantiate": (input) => {
 			const templateId = string(input, "template_id");
 			const template = artifacts.get(templateId);
-			// Deliberately pass an unresolved kind so only the discourse claim (kind-agnostic) can match here —
-			// the historical requireDiscourseStoreForSubtype never checked notes at this call site; that check
-			// already happens inside instantiateTemplate's own rejectsNoteTemplate for the non-task branch below.
-			authority.requireArtifactAllowed(undefined, templateSubtype(artifacts, templateId), "create", GENERIC_CALLER);
+			// Note ownership for a non-task template target is enforced inside instantiateTemplate's
+			// own rejectsNoteTemplate for the non-task branch below -- nothing else currently claims
+			// an unresolved (pre-template-resolution) kind, so there is no check to perform here.
 			if (template?.extra["targetKind"] !== "task") return instantiateTemplate(artifacts, templateId, normalizeCreateInput(input), authority, eventContext(input));
 			return tasks.create({
 				title: optionalString(input, "title") as string,
@@ -371,6 +364,8 @@ function handlers(
 		},
 		"graph_projection.apply": forwardToModule("graph_projection.apply"),
 		"graph_projection.checkpoint": forwardToModule("graph_projection.checkpoint"),
+		"logs.append": forwardToModule("logs.append"),
+		"logs.query": forwardToModule("logs.query"),
 	};
 }
 
@@ -383,18 +378,19 @@ export function createPapyrusService(path: string): PapyrusService {
 	const scopes = new SQLiteTaskScopeStore(db);
 	const tasks = new Tasks(artifacts, gates, focus, events, scopes);
 	const notes = new Notes(artifacts);
-	const discourse = new SQLiteDiscourseStore(db, artifacts);
 	const projections = new SQLiteGraphProjectionStore(db);
 	const artifactScopes = new SQLiteArtifactScopeStore(db);
+	const logs = new Logs(new SQLiteLogStore(db));
 	const authority = createAuthorityRegistry();
 	const moduleRegistry = new OperationRegistry();
 	moduleRegistry.registerAll(notesOperations(notes));
+	moduleRegistry.registerAll(logsOperations(logs));
 	moduleRegistry.registerAll(tasksOperations(tasks, artifacts));
 	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority));
 	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes));
 	moduleRegistry.registerAll(skillsOperations({ artifacts, events, scopes, artifactScopes, authority }));
 	moduleRegistry.registerAll(graphProjectionOperations(artifacts, projections, authority));
-	const registry = handlers(artifacts, gates, tasks, notes, discourse, events, scopes, () => migrateDb(db), moduleRegistry, authority);
+	const registry = handlers(artifacts, gates, tasks, notes, events, scopes, () => migrateDb(db), moduleRegistry, authority);
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };

package/src/adapters/sqlite-discourse-store.ts

@@ -1,325 +0,0 @@
-import { DISCOURSE_PARTICIPANT_MAX_COUNT } from "../constants.ts";
-import type { Db } from "../db.ts";
-import { inTransaction } from "../db.ts";
-import {
-	appendCommand,
-	DISCOURSE_MESSAGE_SUBTYPE,
-	DISCOURSE_THREAD_SUBTYPE,
-	eventRetention,
-	nonNegativeInteger,
-	optionalString,
-	queryLimit,
-	requiredString,
-	threadAddress,
-	type AppendPostCommand,
-	type DiscourseEvent,
-	type DiscourseEventType,
-	type JsonValue,
-	type OpenQuestion,
-	type Page,
-	type Post,
-	type ProjectionRecord,
-	type ThreadSummary,
-	type TopicSummary,
-} from "../domain/discourse-store.ts";
-import type { AtomicArtifactStore } from "../ports/atomic-artifact-store.ts";
-
-interface QuestionColumns {
-	questionType?: "question" | "answer";
-	responseId?: string;
-	targetId?: string;
-}
-
-type Row = Record<string, unknown>;
-
-function rowString(row: Row, name: string): string {
-	const value = row[name];
-	if (typeof value !== "string") throw new Error(`invalid persisted ${name}`);
-	return value;
-}
-
-function rowOptionalString(row: Row, name: string): string | undefined {
-	const value = row[name];
-	return typeof value === "string" ? value : undefined;
-}
-
-function rowNumber(row: Row, name: string): number {
-	const value = Number(row[name]);
-	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`invalid persisted ${name}`);
-	return value;
-}
-
-function parseJson<T>(row: Row, name: string): T {
-	return JSON.parse(rowString(row, name)) as T;
-}
-
-function postFromRow(row: Row): Post {
-	return {
-		id: rowString(row, "id"),
-		sequence: rowNumber(row, "sequence"),
-		operationId: rowString(row, "operation_id"),
-		forumId: rowString(row, "forum_id"),
-		topicId: rowString(row, "topic_id"),
-		threadId: rowString(row, "thread_id"),
-		authorId: rowString(row, "author_id"),
-		content: parseJson<JsonValue>(row, "content_json"),
-		timestamp: rowNumber(row, "timestamp"),
-		references: parseJson(row, "references_json"),
-		...(rowOptionalString(row, "correlation_id") ? { correlationId: rowString(row, "correlation_id") } : {}),
-		...(rowOptionalString(row, "causation_id") ? { causationId: rowString(row, "causation_id") } : {}),
-		...(rowOptionalString(row, "reply_to_post_id") ? { replyToPostId: rowString(row, "reply_to_post_id") } : {}),
-	};
-}
-
-function page<T>(items: T[], limit: number, sequenceOf?: (item: T) => number): Page<T> {
-	const truncated = items.length > limit;
-	const selected = items.slice(0, limit);
-	const last = selected.at(-1);
-	return {
-		items: selected,
-		truncated,
-		completeness: truncated ? "truncated" : "complete",
-		...(truncated && last !== undefined && sequenceOf ? { nextSequence: sequenceOf(last) } : {}),
-	};
-}
-
-function questionColumns(content: JsonValue): QuestionColumns {
-	if (typeof content !== "object" || content === null || Array.isArray(content)) return {};
-	const type = content["type"];
-	const responseId = content["responseId"];
-	const targetId = content["targetId"];
-	if ((type !== "question" && type !== "answer") || typeof responseId !== "string" || responseId.length === 0) return {};
-	return { questionType: type, responseId, ...(typeof targetId === "string" && targetId.length > 0 ? { targetId } : {}) };
-}
-
-function eventsFor(command: AppendPostCommand, postId: string, timestamp: number, firstSequence: number): DiscourseEvent[] {
-	const question = questionColumns(command.content);
-	const metadata: Array<{ type: DiscourseEventType; responseId?: string }> = [
-		{ type: "post-added" },
-		{ type: "thread-changed" },
-	];
-	if (question.questionType) {
-		metadata.push({
-			type: question.questionType === "question" ? "question-opened" : "question-answered",
-			responseId: question.responseId,
-		});
-	}
-	return metadata.map((event, index) => ({
-		schemaVersion: "discourse.event.v1",
-		type: event.type,
-		sequence: firstSequence + index,
-		timestamp,
-		forumId: command.forumId,
-		topicId: command.topicId,
-		threadId: command.threadId,
-		postId,
-		operationId: command.operationId,
-		...(command.correlationId ? { correlationId: command.correlationId } : {}),
-		...(command.causationId ? { causationId: command.causationId } : {}),
-		...(event.responseId ? { responseId: event.responseId } : {}),
-	}));
-}
-
-function bodyFor(content: JsonValue): string {
-	return typeof content === "string" ? content : JSON.stringify(content, null, 2);
-}
-
-/** Durable graph adapter used only behind the Discourse application mutation boundary. */
-export class SQLiteDiscourseStore {
-	constructor(private readonly db: Db, private readonly artifacts: AtomicArtifactStore) {}
-
-	execute(input: Record<string, unknown>): unknown {
-		const action = requiredString(input["action"], "action");
-		const storeId = requiredString(input["store_id"], "store_id");
-		switch (action) {
-			case "append":
-				return this.append(
-					storeId,
-					appendCommand(input["command"]),
-					requiredString(input["post_id"], "post_id"),
-					nonNegativeInteger(input["timestamp"], "timestamp"),
-					eventRetention(input["event_retention"]),
-				);
-			case "read_thread":
-				return this.readThread(storeId, input);
-			case "list_topics":
-				return this.listTopics(storeId, requiredString(input["forumId"], "forumId"), queryLimit(input["limit"]));
-			case "list_threads":
-				return this.listThreads(storeId, requiredString(input["forumId"], "forumId"), requiredString(input["topicId"], "topicId"), queryLimit(input["limit"]));
-			case "open_questions":
-				return this.openQuestions(storeId, optionalString(input["forumId"], "forumId"), optionalString(input["targetId"], "targetId"), queryLimit(input["limit"]));
-			case "replay":
-				return this.replay(storeId, nonNegativeInteger(input["after_sequence"], "after_sequence"), queryLimit(input["limit"]));
-			case "snapshot":
-				return this.snapshot(storeId, input);
-			case "acknowledge":
-				return this.acknowledge(storeId, requiredString(input["consumer_id"], "consumer_id"), nonNegativeInteger(input["sequence"], "sequence"));
-			case "consumer_cursor":
-				return this.cursor("discourse_cursors", "consumer_id", storeId, requiredString(input["consumer_id"], "consumer_id"));
-			case "read_projection_outbox":
-				return this.projectionOutbox(storeId, requiredString(input["projection_id"], "projection_id"), queryLimit(input["limit"]));
-			case "acknowledge_projection":
-				this.acknowledgeProjection(storeId, requiredString(input["projection_id"], "projection_id"), nonNegativeInteger(input["sequence"], "sequence"));
-				return { ok: true };
-			case "projection_checkpoint":
-				return this.cursor("discourse_projection_cursors", "projection_id", storeId, requiredString(input["projection_id"], "projection_id"));
-			case "projection_pending":
-				return this.projectionPending(storeId, requiredString(input["projection_id"], "projection_id"));
-			case "latest_post_sequence":
-				return this.maximum(storeId, "discourse_posts");
-			default:
-				throw new Error(`unknown discourse store action "${action}"`);
-		}
-	}
-
-	private append(storeId: string, command: AppendPostCommand, postId: string, timestamp: number, retention: number): { post: Post; replayed: boolean; events: DiscourseEvent[] } {
-		return inTransaction(this.db, () => {
-			const prior = this.db.prepare("SELECT * FROM discourse_posts WHERE store_id = ? AND operation_id = ?").get(storeId, command.operationId) as Row | null;
-			const commandJson = JSON.stringify(command);
-			if (prior) {
-				if (rowString(prior, "command_json") !== commandJson) throw new Error(`operation conflict: ${command.operationId}`);
-				return { post: postFromRow(prior), replayed: true, events: [] };
-			}
-			for (const reference of command.references ?? []) {
-				const artifact = this.artifacts.get(reference.id);
-				if (!artifact || artifact.kind !== reference.kind) throw new Error(`artifact reference not verified: ${reference.kind}:${reference.id}`);
-			}
-			let replyArtifactId: string | undefined;
-			if (command.replyToPostId) {
-				const parent = this.db.prepare("SELECT forum_id, topic_id, thread_id, artifact_id FROM discourse_posts WHERE store_id = ? AND id = ?").get(storeId, command.replyToPostId) as Row | null;
-				if (!parent) throw new Error(`reply target not found: ${command.replyToPostId}`);
-				if (rowString(parent, "forum_id") !== command.forumId || rowString(parent, "topic_id") !== command.topicId || rowString(parent, "thread_id") !== command.threadId) {
-					throw new Error("reply target must belong to the same thread");
-				}
-				replyArtifactId = rowString(parent, "artifact_id");
-			}
-			const firstSequence = this.maximum(storeId, "discourse_events") + 1;
-			const events = eventsFor(command, postId, timestamp, firstSequence);
-			const threadArtifactId = this.ensureThread(storeId, command);
-			const message = this.artifacts.create({
-				kind: "doc",
-				title: `${command.authorId} · ${command.threadId} · ${firstSequence}`,
-				status: "active",
-				subtype: DISCOURSE_MESSAGE_SUBTYPE,
-				body: bodyFor(command.content),
-				extra: {
-					storeId, postId, sequence: firstSequence, operationId: command.operationId,
-					forumId: command.forumId, topicId: command.topicId, threadId: command.threadId,
-					authorId: command.authorId, timestamp,
-				},
-			});
-			const question = questionColumns(command.content);
-			this.db.prepare(`INSERT INTO discourse_posts (
-				store_id, sequence, id, artifact_id, operation_id, command_json, forum_id, topic_id, thread_id,
-				author_id, content_json, timestamp, correlation_id, causation_id, reply_to_post_id, references_json,
-				question_type, response_id, target_id
-			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
-				storeId, firstSequence, postId, message.id, command.operationId, commandJson,
-				command.forumId, command.topicId, command.threadId, command.authorId, JSON.stringify(command.content), timestamp,
-				command.correlationId ?? null, command.causationId ?? null, command.replyToPostId ?? null,
-				JSON.stringify(command.references ?? []), question.questionType ?? null, question.responseId ?? null, question.targetId ?? null,
-			);
-			this.artifacts.link({ from: threadArtifactId, relation: "contains", to: message.id });
-			this.artifacts.link({ from: message.id, relation: "part_of", to: threadArtifactId });
-			if (replyArtifactId) this.artifacts.link({ from: message.id, relation: "reply_to", to: replyArtifactId });
-			for (const reference of command.references ?? []) this.artifacts.link({ from: message.id, relation: "discusses", to: reference.id });
-			for (const event of events) {
-				this.db.prepare("INSERT INTO discourse_events (store_id, sequence, event_json) VALUES (?, ?, ?)").run(storeId, event.sequence, JSON.stringify(event));
-			}
-			const latest = events.at(-1);
-			if (!latest) throw new Error("append produced no events");
-			this.db.prepare("DELETE FROM discourse_events WHERE store_id = ? AND sequence <= ?").run(storeId, latest.sequence - retention);
-			return { post: postFromRow(this.db.prepare("SELECT * FROM discourse_posts WHERE store_id = ? AND id = ?").get(storeId, postId) as Row), replayed: false, events };
-		});
-	}
-
-	private ensureThread(storeId: string, address: AppendPostCommand): string {
-		const existing = this.db.prepare("SELECT artifact_id FROM discourse_threads WHERE store_id = ? AND forum_id = ? AND topic_id = ? AND thread_id = ?").get(storeId, address.forumId, address.topicId, address.threadId) as Row | null;
-		if (existing) return rowString(existing, "artifact_id");
-		const thread = this.artifacts.create({
-			kind: "doc", title: address.threadId, status: "active", subtype: DISCOURSE_THREAD_SUBTYPE,
-			extra: { storeId, forumId: address.forumId, topicId: address.topicId, threadId: address.threadId },
-		});
-		this.db.prepare("INSERT INTO discourse_threads (store_id, forum_id, topic_id, thread_id, artifact_id) VALUES (?, ?, ?, ?, ?)").run(storeId, address.forumId, address.topicId, address.threadId, thread.id);
-		return thread.id;
-	}
-
-	private readThread(storeId: string, input: Record<string, unknown>): Page<Post> {
-		const address = threadAddress(input);
-		const limit = queryLimit(input["limit"]);
-		const after = input["afterSequence"] === undefined ? 0 : nonNegativeInteger(input["afterSequence"], "afterSequence");
-		const rows = this.db.prepare("SELECT * FROM discourse_posts WHERE store_id = ? AND forum_id = ? AND topic_id = ? AND thread_id = ? AND sequence > ? ORDER BY sequence LIMIT ?").all(storeId, address.forumId, address.topicId, address.threadId, after, limit + 1) as Row[];
-		return page(rows.map(postFromRow), limit, (post) => post.sequence);
-	}
-
-	private listTopics(storeId: string, forumId: string, limit: number): Page<TopicSummary> {
-		const rows = this.db.prepare("SELECT forum_id, topic_id, COUNT(DISTINCT thread_id) AS thread_count, COUNT(*) AS post_count, MAX(timestamp) AS last_activity FROM discourse_posts WHERE store_id = ? AND forum_id = ? GROUP BY forum_id, topic_id ORDER BY topic_id LIMIT ?").all(storeId, forumId, limit + 1) as Row[];
-		return page(rows.map((row) => ({ forumId: rowString(row, "forum_id"), topicId: rowString(row, "topic_id"), threadCount: rowNumber(row, "thread_count"), postCount: rowNumber(row, "post_count"), lastActivity: rowNumber(row, "last_activity") })), limit);
-	}
-
-	private listThreads(storeId: string, forumId: string, topicId: string, limit: number): Page<ThreadSummary> {
-		const rows = this.db.prepare("SELECT forum_id, topic_id, thread_id, COUNT(*) AS post_count, MAX(timestamp) AS last_activity FROM discourse_posts WHERE store_id = ? AND forum_id = ? AND topic_id = ? GROUP BY forum_id, topic_id, thread_id ORDER BY thread_id LIMIT ?").all(storeId, forumId, topicId, limit + 1) as Row[];
-		return page(rows.map((row) => {
-			const threadId = rowString(row, "thread_id");
-			const participants = this.db.prepare("SELECT DISTINCT author_id FROM discourse_posts WHERE store_id = ? AND forum_id = ? AND topic_id = ? AND thread_id = ? ORDER BY author_id LIMIT ?").all(storeId, forumId, topicId, threadId, DISCOURSE_PARTICIPANT_MAX_COUNT) as Row[];
-			return { forumId, topicId, threadId, postCount: rowNumber(row, "post_count"), participantIds: participants.map((entry) => rowString(entry, "author_id")), lastActivity: rowNumber(row, "last_activity") };
-		}), limit);
-	}
-
-	private openQuestions(storeId: string, forumId: string | undefined, targetId: string | undefined, limit: number): Page<OpenQuestion> {
-		const rows = this.db.prepare("SELECT p.* FROM discourse_posts p WHERE p.store_id = ? AND p.question_type = 'question' AND (? IS NULL OR p.forum_id = ?) AND (? IS NULL OR p.target_id IS NULL OR p.target_id = ?) AND NOT EXISTS (SELECT 1 FROM discourse_posts a WHERE a.store_id = p.store_id AND a.question_type = 'answer' AND a.response_id = p.response_id) ORDER BY p.sequence LIMIT ?").all(storeId, forumId ?? null, forumId ?? null, targetId ?? null, targetId ?? null, limit + 1) as Row[];
-		return page(rows.map((row) => ({ responseId: rowString(row, "response_id"), post: postFromRow(row) })), limit, (question) => question.post.sequence);
-	}
-
-	private replay(storeId: string, afterSequence: number, limit: number): { events: DiscourseEvent[]; retainedFromSequence: number; latestSequence: number; expired: boolean; truncated: boolean } {
-		const bounds = this.db.prepare("SELECT COALESCE(MIN(sequence), 0) AS minimum, COALESCE(MAX(sequence), 0) AS maximum FROM discourse_events WHERE store_id = ?").get(storeId) as Row;
-		const retainedFromSequence = rowNumber(bounds, "minimum");
-		const latestSequence = rowNumber(bounds, "maximum");
-		const expired = retainedFromSequence > 0 && afterSequence > 0 && afterSequence < retainedFromSequence - 1;
-		const rows = expired ? [] : this.db.prepare("SELECT event_json FROM discourse_events WHERE store_id = ? AND sequence > ? ORDER BY sequence LIMIT ?").all(storeId, afterSequence, limit + 1) as Row[];
-		const events = rows.map((row) => parseJson<DiscourseEvent>(row, "event_json"));
-		return { events: events.slice(0, limit), retainedFromSequence, latestSequence, expired, truncated: events.length > limit };
-	}
-
-	private snapshot(storeId: string, input: Record<string, unknown>): { posts: Page<Post>; throughSequence: number } {
-		const limit = queryLimit(input["limit"]);
-		const after = input["afterSequence"] === undefined ? 0 : nonNegativeInteger(input["afterSequence"], "afterSequence");
-		const forumId = optionalString(input["forumId"], "forumId");
-		const rows = this.db.prepare("SELECT * FROM discourse_posts WHERE store_id = ? AND sequence > ? AND (? IS NULL OR forum_id = ?) ORDER BY sequence LIMIT ?").all(storeId, after, forumId ?? null, forumId ?? null, limit + 1) as Row[];
-		return { posts: page(rows.map(postFromRow), limit, (post) => post.sequence), throughSequence: this.maximum(storeId, "discourse_events") };
-	}
-
-	private acknowledge(storeId: string, consumerId: string, sequence: number): number {
-		const latest = this.maximum(storeId, "discourse_events");
-		if (sequence > latest) throw new Error(`cannot acknowledge future sequence ${sequence}`);
-		this.db.prepare("INSERT INTO discourse_cursors (store_id, consumer_id, sequence) VALUES (?, ?, ?) ON CONFLICT(store_id, consumer_id) DO UPDATE SET sequence = MAX(sequence, excluded.sequence)").run(storeId, consumerId, sequence);
-		return this.cursor("discourse_cursors", "consumer_id", storeId, consumerId);
-	}
-
-	private projectionOutbox(storeId: string, projectionId: string, limit: number): ProjectionRecord[] {
-		const checkpoint = this.cursor("discourse_projection_cursors", "projection_id", storeId, projectionId);
-		return (this.db.prepare("SELECT * FROM discourse_posts WHERE store_id = ? AND sequence > ? ORDER BY sequence LIMIT ?").all(storeId, checkpoint, limit) as Row[]).map((row) => {
-			const post = postFromRow(row);
-			return { sequence: post.sequence, post };
-		});
-	}
-
-	private acknowledgeProjection(storeId: string, projectionId: string, sequence: number): void {
-		if (sequence > this.maximum(storeId, "discourse_posts")) throw new Error(`cannot acknowledge future projection sequence ${sequence}`);
-		this.db.prepare("INSERT INTO discourse_projection_cursors (store_id, projection_id, sequence) VALUES (?, ?, ?) ON CONFLICT(store_id, projection_id) DO UPDATE SET sequence = MAX(sequence, excluded.sequence)").run(storeId, projectionId, sequence);
-	}
-
-	private projectionPending(storeId: string, projectionId: string): number {
-		const checkpoint = this.cursor("discourse_projection_cursors", "projection_id", storeId, projectionId);
-		return rowNumber(this.db.prepare("SELECT COUNT(*) AS value FROM discourse_posts WHERE store_id = ? AND sequence > ?").get(storeId, checkpoint) as Row, "value");
-	}
-
-	private cursor(table: "discourse_cursors" | "discourse_projection_cursors", column: "consumer_id" | "projection_id", storeId: string, id: string): number {
-		const row = this.db.prepare(`SELECT sequence FROM ${table} WHERE store_id = ? AND ${column} = ?`).get(storeId, id) as Row | null;
-		return row ? rowNumber(row, "sequence") : 0;
-	}
-
-	private maximum(storeId: string, table: "discourse_events" | "discourse_posts"): number {
-		return rowNumber(this.db.prepare(`SELECT COALESCE(MAX(sequence), 0) AS value FROM ${table} WHERE store_id = ?`).get(storeId) as Row, "value");
-	}
-}