@danypops/papyrus 0.14.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],

package/src/authority-registry.ts

@@ -25,7 +25,7 @@ import type { ArtifactStore } from "./ports/artifact-store.ts";
 export type ArtifactAction = "create" | "link" | "status";
 
 export interface AuthorityClaim {
-	/** Module id that owns this kind/subtype/relation, e.g. "discourse", "notes", "tasks". */
+	/** Module id that owns this kind/subtype/relation, e.g. "notes", "tasks". */
 	readonly owner: string;
 	/** kind may be undefined at a call site that has not yet resolved an artifact's effective kind (e.g. pre-template-resolution). */
 	matchesArtifact(kind: string | undefined, subtype: string | undefined): boolean;

package/src/cli.ts

@@ -71,7 +71,6 @@ const USAGE = `Usage:
   papyrus migrate-ids mirror [--db <path>] --out <mirror-path> [--json]
   papyrus migrate-ids validate --mirror <mirror-path> [--idmap <path>] [--json]
   papyrus migrate-ids promote --mirror <mirror-path> [--db <path>] [--idmap <path>] [--force] [--json]
-  papyrus discourse store <action> --store-id <id> [--input-json <json>] [--json]
   papyrus graph link <from> <relation> <to> [--json]
   papyrus graph unlink <from> <relation> <to> [--json]
   papyrus graph tree <id> [--depth <n>] [--max-nodes <n>] [--json]
@@ -308,36 +307,6 @@ export function runIdMigrationCli(args: string[]): string {
 	throw new Error("migrate-ids requires one of: mirror, validate, promote");
 }
 
-export async function runDiscourseCli(args: string[], client: TaskCliClient): Promise<string> {
-	const json = args.includes("--json");
-	const positional: string[] = [];
-	let storeId: string | undefined;
-	let operationInput: Record<string, unknown> = {};
-	for (let index = 0; index < args.length; index++) {
-		const argument = args[index]!;
-		if (argument === "--json") continue;
-		if (argument === "--store-id" || argument === "--input-json") {
-			const value = args[++index];
-			if (!value) throw new Error(`${argument} requires a value`);
-			if (argument === "--store-id") storeId = value;
-			else {
-				const parsed = JSON.parse(value) as unknown;
-				if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("--input-json must be a JSON object");
-				operationInput = parsed as Record<string, unknown>;
-			}
-			continue;
-		}
-		if (argument.startsWith("--")) throw new Error(`unknown discourse option ${argument}`);
-		positional.push(argument);
-	}
-	if (positional.length !== 2 || positional[0] !== "store") throw new Error("discourse requires `store <action>`");
-	if (!storeId) throw new Error("discourse store requires --store-id");
-	const result = await client.call<Record<string, unknown>, unknown>("discourse.store", {
-		action: positional[1], store_id: storeId, ...operationInput,
-	});
-	return json ? JSON.stringify(result) : `Discourse store ${positional[1]} completed.`;
-}
-
 export async function runSkillCli(args: string[], client: TaskCliClient, projectRoot: string = process.cwd()): Promise<string> {
 	const json = args.includes("--json");
 	const positional: string[] = [];
@@ -1324,11 +1293,6 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 		console.log(await runTaskCli(args.slice(1), client));
 		return;
 	}
-	if (command === "discourse") {
-		const client = await connectPapyrusClient();
-		console.log(await runDiscourseCli(args.slice(1), client));
-		return;
-	}
 	if (command === "skills") {
 		const client = await connectPapyrusClient();
 		console.log(await runSkillCli(args.slice(1), client));

package/src/constants.ts

@@ -7,14 +7,9 @@ export const DAEMON_PROBE_TIMEOUT_MS = 800;
 export const DAEMON_UNIT_NAME = "papyrus.service";
 export const DAEMON_DIR_ENV = "PAPYRUS_DAEMON_DIR";
 export const SQLITE_BUSY_TIMEOUT_MS = 5_000;
-export const SQLITE_SCHEMA_VERSION = 11;
+export const SQLITE_SCHEMA_VERSION = 12;
 export const SERVICE_MAX_BODY_BYTES = 1_048_576;
-/** Bounded forum persistence behind the Discourse mutation authority. */
-export const DISCOURSE_QUERY_MAX_LIMIT = 100;
-export const DISCOURSE_CONTENT_MAX_BYTES = 65_536;
-export const DISCOURSE_EVENT_RETENTION_DEFAULT = 1_000;
-export const DISCOURSE_EVENT_RETENTION_MAX = 10_000;
-export const DISCOURSE_PARTICIPANT_MAX_COUNT = 100;
+
 export const WAL_CHECKPOINT_INTERVAL_MS = 60_000;
 export const DB_OPTIMIZE_INTERVAL_MS = 24 * 60 * 60_000;
 export const GATE_COMMAND_TIMEOUT_MS = 30_000;

package/src/db.ts

@@ -147,67 +147,6 @@ CREATE TABLE IF NOT EXISTS task_views (
 	updated_at    TEXT NOT NULL,
 	CHECK ((mode = 'graph' AND root_task_id IS NOT NULL) OR (mode != 'graph' AND root_task_id IS NULL))
 );
-CREATE TABLE IF NOT EXISTS discourse_threads (
-	store_id      TEXT NOT NULL,
-	forum_id      TEXT NOT NULL,
-	topic_id      TEXT NOT NULL,
-	thread_id     TEXT NOT NULL,
-	artifact_id   TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
-	PRIMARY KEY (store_id, forum_id, topic_id, thread_id)
-);
-CREATE TABLE IF NOT EXISTS discourse_posts (
-	store_id       TEXT NOT NULL,
-	sequence       INTEGER NOT NULL,
-	id             TEXT NOT NULL,
-	artifact_id    TEXT NOT NULL UNIQUE REFERENCES artifacts(id),
-	operation_id   TEXT NOT NULL,
-	command_json   TEXT NOT NULL,
-	forum_id       TEXT NOT NULL,
-	topic_id       TEXT NOT NULL,
-	thread_id      TEXT NOT NULL,
-	author_id      TEXT NOT NULL,
-	content_json   TEXT NOT NULL,
-	timestamp      INTEGER NOT NULL,
-	correlation_id TEXT,
-	causation_id   TEXT,
-	reply_to_post_id TEXT,
-	references_json TEXT NOT NULL,
-	question_type  TEXT CHECK (question_type IN ('question', 'answer')),
-	response_id    TEXT,
-	target_id      TEXT,
-	PRIMARY KEY (store_id, id),
-	UNIQUE (store_id, operation_id),
-	UNIQUE (store_id, sequence)
-);
-CREATE INDEX IF NOT EXISTS discourse_posts_thread_idx ON discourse_posts(store_id, forum_id, topic_id, thread_id, sequence);
-CREATE TABLE IF NOT EXISTS discourse_events (
-	store_id       TEXT NOT NULL,
-	sequence       INTEGER NOT NULL,
-	event_json     TEXT NOT NULL,
-	PRIMARY KEY (store_id, sequence)
-);
-CREATE TABLE IF NOT EXISTS discourse_cursors (
-	store_id       TEXT NOT NULL,
-	consumer_id    TEXT NOT NULL,
-	sequence       INTEGER NOT NULL,
-	PRIMARY KEY (store_id, consumer_id)
-);
-CREATE TABLE IF NOT EXISTS discourse_projection_cursors (
-	store_id       TEXT NOT NULL,
-	projection_id  TEXT NOT NULL,
-	sequence       INTEGER NOT NULL,
-	PRIMARY KEY (store_id, projection_id)
-);
-CREATE TRIGGER IF NOT EXISTS discourse_threads_artifact_type BEFORE INSERT ON discourse_threads
-WHEN NOT EXISTS (SELECT 1 FROM artifacts WHERE id = NEW.artifact_id AND kind = 'doc' AND subtype = 'context-thread')
-BEGIN SELECT RAISE(ABORT, 'discourse thread artifact must be a context-thread Doc'); END;
-CREATE TRIGGER IF NOT EXISTS discourse_posts_artifact_type BEFORE INSERT ON discourse_posts
-WHEN NOT EXISTS (SELECT 1 FROM artifacts WHERE id = NEW.artifact_id AND kind = 'doc' AND subtype = 'context-message')
-BEGIN SELECT RAISE(ABORT, 'discourse post artifact must be a context-message Doc'); END;
-CREATE TRIGGER IF NOT EXISTS discourse_artifact_type_immutable BEFORE UPDATE OF kind, subtype ON artifacts
-WHEN (EXISTS (SELECT 1 FROM discourse_threads WHERE artifact_id = OLD.id) AND (NEW.kind != 'doc' OR NEW.subtype != 'context-thread'))
-  OR (EXISTS (SELECT 1 FROM discourse_posts WHERE artifact_id = OLD.id) AND (NEW.kind != 'doc' OR NEW.subtype != 'context-message'))
-BEGIN SELECT RAISE(ABORT, 'discourse Context Mesh artifact type is immutable'); END;
 CREATE TABLE IF NOT EXISTS artifact_events (
 	id                   INTEGER PRIMARY KEY AUTOINCREMENT,
 	artifact_id          TEXT NOT NULL REFERENCES artifacts(id),
@@ -303,8 +242,6 @@ INSERT OR IGNORE INTO relation_names VALUES ('gates','This rule gates that task
 INSERT OR IGNORE INTO relation_names VALUES ('triggers','This skill applies to that work (skill→task)');
 INSERT OR IGNORE INTO relation_names VALUES ('contains','Parent contains a nested artifact (any→any)');
 INSERT OR IGNORE INTO relation_names VALUES ('part_of','Artifact belongs to a parent artifact (any→any)');
-INSERT OR IGNORE INTO relation_names VALUES ('reply_to','Append-only message replies to another message in the same thread');
-INSERT OR IGNORE INTO relation_names VALUES ('discusses','Message or turn concerns a verified artifact');
 CREATE INDEX IF NOT EXISTS edges_to_id_idx ON edges(to_id);
 `;
 
@@ -349,6 +286,7 @@ const CORE_LEDGER_VERSIONS: ReadonlyArray<{ version: number; name: string; check
 	{ version: 1, name: "baseline", checksum: "af81e9f51d915ba538af3f468dc044bda5e2c5a5f5037e9c7c01540f87288763" },
 	{ version: 2, name: "docs-rules-skills-project-scope", checksum: "8b16d8f631ad628f4799ff09b1ebe8be28343e4f677d52bf2a39a8bedc19e64e" },
 	{ version: 3, name: "log-domain", checksum: "c87f43c22b2608619ada9a529d7899ae74b7f38cd554135c8034116fc96e1eff" },
+	{ version: 4, name: "remove-discourse", checksum: "b923f41c44460f0aaeb2f4e60e28f8b8e1425d03f527955bd991434b46de4c82" },
 ];
 
 export function migrationLedger(db: Db): ModuleMigrationRow[] {
@@ -675,6 +613,30 @@ export function migrateDb(db: Db): MigrationResult {
 			`);
 			applied.push("log-domain");
 		}
+		if (schemaVersion(db) === 11) {
+			// Removes Discourse's Papyrus-embedded storage entirely: confirmed zero rows in every
+			// discourse_* table and zero Docs carrying the reserved context-thread/context-message
+			// subtypes in the real production database before this was written -- Discourse's real
+			// home is now the standalone @danypops/discourse package plus host adapters, and
+			// Papyrus's own copy never had a single real caller since it was built. IF EXISTS
+			// throughout: a database that never actually reached the v5->v6 discourse-context-mesh
+			// step in the first place (e.g. a test fixture that starts partway through the chain)
+			// must not fail here just because there was nothing to remove.
+			db.exec(`
+				DROP TRIGGER IF EXISTS discourse_artifact_type_immutable;
+				DROP TRIGGER IF EXISTS discourse_posts_artifact_type;
+				DROP TRIGGER IF EXISTS discourse_threads_artifact_type;
+				DROP INDEX IF EXISTS discourse_posts_thread_idx;
+				DROP TABLE IF EXISTS discourse_projection_cursors;
+				DROP TABLE IF EXISTS discourse_cursors;
+				DROP TABLE IF EXISTS discourse_events;
+				DROP TABLE IF EXISTS discourse_posts;
+				DROP TABLE IF EXISTS discourse_threads;
+				DELETE FROM relation_names WHERE name IN ('reply_to', 'discusses');
+				PRAGMA user_version = 12;
+			`);
+			applied.push("remove-discourse");
+		}
 		if (schemaVersion(db) !== SQLITE_SCHEMA_VERSION) throw new Error(`no explicit migration path from database schema ${from}`);
 	});
 	if (schemaVersion(db) === SQLITE_SCHEMA_VERSION) ensureCoreLedger(db, true);

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/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";
@@ -41,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;
@@ -129,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,
@@ -158,7 +150,7 @@ const tasksAuthorityClaim: AuthorityClaim = {
 
 function createAuthorityRegistry(): AuthorityRegistry {
 	const authority = new AuthorityRegistry();
-	authority.claimAll([discourseAuthorityClaim, notesAuthorityClaim, tasksAuthorityClaim]);
+	authority.claimAll([notesAuthorityClaim, tasksAuthorityClaim]);
 	return authority;
 }
 
@@ -182,7 +174,6 @@ function handlers(
 	gates: GateRunner,
 	tasks: Tasks,
 	notes: Notes,
-	discourse: SQLiteDiscourseStore,
 	events: TaskEventStore,
 	scopes: TaskScopeStore,
 	migrate: () => unknown,
@@ -219,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);
@@ -357,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,
@@ -389,7 +378,6 @@ 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));
@@ -402,7 +390,7 @@ export function createPapyrusService(path: string): PapyrusService {
 	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");
-	}
-}

package/src/domain/discourse-store.ts

@@ -1,142 +0,0 @@
-import {
-	DISCOURSE_CONTENT_MAX_BYTES,
-	DISCOURSE_EVENT_RETENTION_DEFAULT,
-	DISCOURSE_EVENT_RETENTION_MAX,
-	DISCOURSE_QUERY_MAX_LIMIT,
-} from "../constants.ts";
-
-/** Papyrus-owned Doc subtypes reserved for the Discourse persistence adapter. */
-export const DISCOURSE_THREAD_SUBTYPE = "context-thread";
-export const DISCOURSE_MESSAGE_SUBTYPE = "context-message";
-export const DISCOURSE_RELATIONS = new Set(["reply_to", "discusses"]);
-
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
-export interface ArtifactReference { kind: string; id: string }
-export interface ThreadAddress { forumId: string; topicId: string; threadId: string }
-export interface AppendPostCommand extends ThreadAddress {
-	schemaVersion: "discourse.command.v1";
-	operationId: string;
-	authorId: string;
-	content: JsonValue;
-	correlationId?: string;
-	causationId?: string;
-	replyToPostId?: string;
-	references?: ArtifactReference[];
-}
-export interface Post extends ThreadAddress {
-	id: string;
-	authorId: string;
-	content: JsonValue;
-	timestamp: number;
-	sequence: number;
-	operationId: string;
-	correlationId?: string;
-	causationId?: string;
-	replyToPostId?: string;
-	references: ArtifactReference[];
-}
-export type DiscourseEventType = "post-added" | "thread-changed" | "question-opened" | "question-answered" | "subscription-resync-required";
-export interface DiscourseEvent extends ThreadAddress {
-	schemaVersion: "discourse.event.v1";
-	type: DiscourseEventType;
-	sequence: number;
-	timestamp: number;
-	postId?: string;
-	operationId?: string;
-	correlationId?: string;
-	causationId?: string;
-	responseId?: string;
-	retainedFromSequence?: number;
-}
-export interface Page<T> {
-	items: T[];
-	truncated: boolean;
-	nextSequence?: number;
-	completeness: "complete" | "truncated";
-}
-export interface TopicSummary { forumId: string; topicId: string; threadCount: number; postCount: number; lastActivity: number }
-export interface ThreadSummary extends ThreadAddress { postCount: number; participantIds: string[]; lastActivity: number }
-export interface OpenQuestion { responseId: string; post: Post }
-export interface ProjectionRecord { sequence: number; post: Post }
-
-export function isDiscourseSubtype(subtype: string | undefined): boolean {
-	return subtype === DISCOURSE_THREAD_SUBTYPE || subtype === DISCOURSE_MESSAGE_SUBTYPE;
-}
-
-function record(value: unknown, name: string): Record<string, unknown> {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${name} must be an object`);
-	return value as Record<string, unknown>;
-}
-
-export function requiredString(value: unknown, name: string): string {
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${name} is required`);
-	return value;
-}
-
-export function optionalString(value: unknown, name: string): string | undefined {
-	if (value === undefined) return undefined;
-	if (typeof value !== "string" || value.length === 0) throw new Error(`${name} must be a non-empty string`);
-	return value;
-}
-
-export function nonNegativeInteger(value: unknown, name: string): number {
-	if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error(`${name} must be a non-negative safe integer`);
-	return value as number;
-}
-
-export function queryLimit(value: unknown): number {
-	const limit = nonNegativeInteger(value, "limit");
-	if (limit < 1 || limit > DISCOURSE_QUERY_MAX_LIMIT) throw new Error(`limit must be between 1 and ${DISCOURSE_QUERY_MAX_LIMIT}`);
-	return limit;
-}
-
-export function eventRetention(value: unknown): number {
-	if (value === undefined) return DISCOURSE_EVENT_RETENTION_DEFAULT;
-	const retention = nonNegativeInteger(value, "event_retention");
-	if (retention < 1 || retention > DISCOURSE_EVENT_RETENTION_MAX) {
-		throw new Error(`event_retention must be between 1 and ${DISCOURSE_EVENT_RETENTION_MAX}`);
-	}
-	return retention;
-}
-
-function jsonValue(value: unknown, name: string): JsonValue {
-	const encoded = JSON.stringify(value);
-	if (encoded === undefined) throw new Error(`${name} must be JSON-serializable`);
-	if (new TextEncoder().encode(encoded).byteLength > DISCOURSE_CONTENT_MAX_BYTES) {
-		throw new Error(`${name} cannot exceed ${DISCOURSE_CONTENT_MAX_BYTES} bytes`);
-	}
-	return JSON.parse(encoded) as JsonValue;
-}
-
-export function appendCommand(value: unknown): AppendPostCommand {
-	const input = record(value, "command");
-	if (input["schemaVersion"] !== "discourse.command.v1") throw new Error("unsupported Discourse command schema");
-	const referencesValue = input["references"] ?? [];
-	if (!Array.isArray(referencesValue)) throw new Error("references must be an array");
-	const references = referencesValue.map((entry, index) => {
-		const reference = record(entry, `references[${index}]`);
-		return { kind: requiredString(reference["kind"], `references[${index}].kind`), id: requiredString(reference["id"], `references[${index}].id`) };
-	});
-	return {
-		schemaVersion: "discourse.command.v1",
-		operationId: requiredString(input["operationId"], "operationId"),
-		forumId: requiredString(input["forumId"], "forumId"),
-		topicId: requiredString(input["topicId"], "topicId"),
-		threadId: requiredString(input["threadId"], "threadId"),
-		authorId: requiredString(input["authorId"], "authorId"),
-		content: jsonValue(input["content"], "content"),
-		...(optionalString(input["correlationId"], "correlationId") ? { correlationId: input["correlationId"] as string } : {}),
-		...(optionalString(input["causationId"], "causationId") ? { causationId: input["causationId"] as string } : {}),
-		...(optionalString(input["replyToPostId"], "replyToPostId") ? { replyToPostId: input["replyToPostId"] as string } : {}),
-		references,
-	};
-}
-
-export function threadAddress(value: Record<string, unknown>): ThreadAddress {
-	return {
-		forumId: requiredString(value["forumId"], "forumId"),
-		topicId: requiredString(value["topicId"], "topicId"),
-		threadId: requiredString(value["threadId"], "threadId"),
-	};
-}