@danypops/papyrus 0.14.0 → 0.15.1

package/extension/src/context-view.ts

@@ -117,7 +117,7 @@ class ContextViewport {
 		} else {
 			lines.push(theme.fg("dim", "No real usage reported yet — sizes below are Papyrus's own estimates only"));
 		}
-		lines.push(renderContextBar(theme, this.breakdown.segments, contentWidth, this.breakdown.effectiveBudget ?? undefined));
+		lines.push(renderContextBar(theme, this.breakdown.segments, contentWidth, this.breakdown.effectiveBudget ?? undefined, this.breakdown.totalTokens ?? undefined));
 		if (this.breakdown.overshootTokens > 0) {
 			lines.push(truncateToWidth(theme.fg("warning", `Estimates exceed real total by ~${this.breakdown.overshootTokens} tok — sizes below are approximate, not exact`), contentWidth, ""));
 		}
@@ -161,6 +161,26 @@ class ContextViewport {
 	}
 }
 
+/**
+ * Distributes `totalCells` proportionally across `weights` (parallel arrays), guaranteeing
+ * every genuinely-positive weight gets at least one cell when there is room for all of them
+ * to (totalCells >= weights.length) -- a real, nonzero segment must stay visible even when
+ * dwarfed by a much larger one, not round away to nothing. The largest resulting cell count
+ * absorbs whatever rounding leaves over or short, so the sum always equals totalCells exactly.
+ */
+function distributeCells(weights: readonly number[], totalCells: number): number[] {
+	const sum = weights.reduce((a, b) => a + b, 0);
+	if (sum <= 0 || totalCells <= 0 || weights.length === 0) return weights.map(() => 0);
+	let cells = weights.map((weight) => Math.round((weight / sum) * totalCells));
+	if (totalCells >= weights.length) cells = cells.map((count) => (count === 0 ? 1 : count));
+	const diff = totalCells - cells.reduce((a, b) => a + b, 0);
+	if (diff !== 0) {
+		const maxIndex = cells.indexOf(Math.max(...cells));
+		cells[maxIndex] = (cells[maxIndex] ?? 0) + diff;
+	}
+	return cells;
+}
+
 /**
  * Renders the context window as one horizontal stacked bar: one colored run of block
  * characters per USED segment, followed by a gray/dim run of "░" cells for the remaining,
@@ -169,23 +189,30 @@ class ContextViewport {
  * divide-by-zero, since 0 used really does mean the whole window is empty right now.
  *
  * `capacity` is the real denominator (Papyrus's own effectiveBudget, matching the percentage
- * already shown in the text line above this bar) that used-vs-unused is measured against. When
- * omitted, or when usage has already exceeded it (overshoot / near-compaction), the bar falls
- * back to filling 100% of its width proportionally among segments -- there is no "unused" left
- * to show gray for once real usage has met or passed the real budget.
+ * already shown in the text line above this bar). `usedTokens` is the real, ground-truth used
+ * amount (breakdown.totalTokens) the used-vs-unused split is measured against -- NOT the sum of
+ * `segments`' own estimates. That distinction is load-bearing: a live-reported bug showed a
+ * fully solid bar with zero gray even though the header read "55.9% of usable budget", because
+ * the old code compared `capacity` against the SUM of estimated segments, which independently
+ * overshot both the real total and the capacity itself (a session whose message-history
+ * estimate alone summed to over 1.5M tokens against a real ~550k total) -- the exact estimate-
+ * overshoot dishonesty `overshootTokens` exists to surface elsewhere was silently defeating the
+ * bar's own gray/used split. `usedTokens` defaults to the segment sum only when omitted, for
+ * callers with no real total available. Segments still split the USED portion proportionally to
+ * their own estimated share of each other (via distributeCells, which also guarantees a tiny
+ * nonzero segment stays visible rather than rounding to nothing next to a much larger one).
  */
-export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number, capacity?: number): string {
-	const total = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
-	if (total <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
-	const nonZero = segments.filter((segment) => segment.estimatedTokens > 0);
-	const usedWidth = capacity !== undefined && capacity > total ? Math.min(width, Math.round((total / capacity) * width)) : width;
+export function renderContextBar(theme: Theme, segments: ReadonlyArray<ContextSegment>, width: number, capacity?: number, usedTokens?: number): string {
+	const estimatedSum = segments.reduce((sum, segment) => sum + segment.estimatedTokens, 0);
+	if (estimatedSum <= 0 || width <= 0) return theme.fg("dim", "░".repeat(Math.max(0, width)));
+	const realUsed = usedTokens ?? estimatedSum;
+	const usedWidth = capacity !== undefined ? Math.max(0, Math.min(width, Math.round((realUsed / capacity) * width))) : width;
 
-	let used = 0;
+	const nonZero = segments.filter((segment) => segment.estimatedTokens > 0);
+	const cellCounts = distributeCells(nonZero.map((segment) => segment.estimatedTokens), usedWidth);
 	let output = "";
 	nonZero.forEach((segment, index) => {
-		const isLast = index === nonZero.length - 1;
-		const cells = isLast ? usedWidth - used : Math.round((segment.estimatedTokens / total) * usedWidth);
-		used += cells;
+		const cells = cellCounts[index] ?? 0;
 		if (cells > 0) output += theme.fg(SEGMENT_COLORS[segment.key], "█".repeat(cells));
 	});
 	const emptyWidth = width - usedWidth;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.14.0",
+  "version": "0.15.1",
   "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;
@@ -35,7 +30,8 @@ export const CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN = 4;
  * tree when estimating /context's message-history and task segments. Both are genuine trees
  * built from external, mutable state (a session file; the live Task graph) -- the node bound
  * is a defensive measure against a corrupted/adversarial parentId chain forming an accidental
- * cycle, matching the same cycle-safety discipline already applied to ConversationJournal
+ * cycle, matching the same cycle-safety discipline established by the (since-removed;
+ * see Doc "ConversationJournal design record") ConversationJournal domain's own reply-chain
  * traversal and deliberately hardening past a real, confirmed gap in Pi's own getBranch() (no
  * cycle guard at all). Set generously: a real, ordinary (non-branching) long-running session
  * is one long linear chain, so a naively small bound truncates the walk after counting only a
@@ -97,8 +93,9 @@ export const SKILL_MAX_RENDERED_BYTES = 1_048_576;
  * to (existing Tasks/Rules/Docs via ordinary edges, not just its own static body/extra
  * fields), and a Skill can link to and invoke other Skills. Both traversals are bounded and
  * cycle-safe -- a skill-calls-skill edge cycle must not infinite-loop invocation, matching
- * the cycle-safety discipline already established for ConversationJournal reply chains and
- * task dependency graphs.
+ * the same cycle-safety discipline established by task dependency graphs and the
+ * (since-removed; see Doc "ConversationJournal design record") ConversationJournal domain's
+ * own reply chains.
  */
 export const SKILL_INVOCATION_MAX_LINKED_ARTIFACTS = 20;
 export const SKILL_INVOCATION_MAX_CALL_DEPTH = 4;

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/domain/log-entry.ts

@@ -10,9 +10,10 @@
  * first-class concern here in a way it deliberately is NOT for the permanent
  * artifact_events/task_events audit trails: logs are meant to be rotated, not kept forever.
  *
- * Mirrors ConversationJournal's own discipline (idempotency via a caller-constructed
- * composite operationId, explicit non-silent truncation) since both are append-only,
- * externally-sourced record streams -- but logs have no reply structure and do carry a
+ * Mirrors the (since-removed; see Doc "ConversationJournal design record") ConversationJournal
+ * domain's own discipline (idempotency via a caller-constructed composite operationId,
+ * explicit non-silent truncation) since both are append-only, externally-sourced record
+ * streams -- but logs have no reply structure and do carry a
  * retention policy, which a durable conversation record deliberately does not.
  */
 
@@ -49,8 +50,9 @@ export interface LogEntry {
 	/**
 	 * Idempotency key. Must be a composite the caller constructs (e.g. `${sessionId}:${turn}`),
 	 * never a bare upstream id alone -- a source's own local ids are commonly unique only
-	 * within one recording run, not globally, matching ConversationJournal's identical
-	 * operationId discipline and the concrete case it generalizes from (Pi's /tree lessons).
+	 * within one recording run, not globally, matching the same operationId discipline
+	 * established by the (since-removed) ConversationJournal domain and the concrete case
+	 * it generalizes from (Pi's /tree lessons).
 	 */
 	readonly operationId: string;
 	readonly sessionId?: string;

package/src/domain-services.ts

@@ -388,8 +388,9 @@ function skillInvocationBody(skill: Artifact): string {
  * workflow execution already uses for skill-to-task edges): invoking the parent recursively
  * composes the linked skill's own invocation. Bounded and cycle-safe -- a skill-calls-skill
  * edge cycle degrades to a marker instead of infinite-looping, matching the cycle-safety
- * discipline already established for ConversationJournal reply chains and task dependency
- * graphs. `visited` and `depth` are recursion-internal; callers should not pass them.
+ * discipline established by task dependency graphs and the (since-removed; see Doc
+ * "ConversationJournal design record") ConversationJournal domain's own reply chains.
+ * `visited` and `depth` are recursion-internal; callers should not pass them.
  */
 export function skillInvocation(artifacts: ArtifactStore, id: string, visited: Set<string> = new Set(), depth = 0): string {
 	const skill = requireKind(artifacts, id, "skill");

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/ports/log-store.ts

@@ -1,10 +1,11 @@
 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.
+ * Persistence port for the `log` domain. Deliberately minimal, matching the split established
+ * by the (since-removed; see Doc "ConversationJournal design record") ConversationJournalStore:
+ * 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;

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/in-memory-conversation-journal-store.ts

@@ -1,48 +0,0 @@
-import type { JournalPost, JournalThread } from "../domain/conversation-journal.ts";
-import type { ConversationJournalStore } from "../ports/conversation-journal-store.ts";
-
-/**
- * Bounded in-memory conformance fixture -- the reference implementation the
- * conversationJournalConformanceSuite is proven against first, before any real
- * persistence backend needs to satisfy the same contract.
- */
-export class InMemoryConversationJournalStore implements ConversationJournalStore {
-	private readonly threads = new Map<string, JournalThread>();
-	private readonly posts = new Map<string, JournalPost>();
-	private readonly postIdsByOperationId = new Map<string, string>();
-	private readonly postIdsByThread = new Map<string, string[]>();
-
-	ensureThread(threadId: string): JournalThread {
-		const existing = this.threads.get(threadId);
-		if (existing) return existing;
-		const thread: JournalThread = { id: threadId, createdAt: new Date().toISOString() };
-		this.threads.set(threadId, thread);
-		return thread;
-	}
-
-	getThread(threadId: string): JournalThread | undefined {
-		return this.threads.get(threadId);
-	}
-
-	findPostByOperationId(operationId: string): JournalPost | undefined {
-		const postId = this.postIdsByOperationId.get(operationId);
-		return postId ? this.posts.get(postId) : undefined;
-	}
-
-	insertPost(post: JournalPost): void {
-		this.posts.set(post.id, post);
-		this.postIdsByOperationId.set(post.operationId, post.id);
-		const ids = this.postIdsByThread.get(post.threadId) ?? [];
-		ids.push(post.id);
-		this.postIdsByThread.set(post.threadId, ids);
-	}
-
-	getPost(id: string): JournalPost | undefined {
-		return this.posts.get(id);
-	}
-
-	postsForThread(threadId: string): readonly JournalPost[] {
-		const ids = this.postIdsByThread.get(threadId) ?? [];
-		return ids.map((id) => this.posts.get(id)!);
-	}
-}

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/conversation-journal-service.ts

@@ -1,87 +0,0 @@
-/**
- * conversation-journal-service.ts — host-neutral ConversationJournal application layer.
- *
- * Owns idempotency (checking operationId before insert) and bounds enforcement; the
- * ConversationJournalStore port underneath is dumb storage. See
- * src/domain/conversation-journal.ts for the domain shapes and the design rationale.
- */
-import {
-	ancestorChain,
-	boundContent,
-	buildThreadTree,
-	CONVERSATION_JOURNAL_READ_MAX_POSTS,
-	validateAppendPostCommand,
-	type AppendPostCommand,
-	type AppendPostResult,
-	type JournalPost,
-	type JournalThread,
-	type ReadThreadQuery,
-	type ThreadPage,
-	type ThreadTreeNode,
-} from "./domain/conversation-journal.ts";
-import type { ConversationJournalStore } from "./ports/conversation-journal-store.ts";
-
-export class ConversationJournalService {
-	constructor(private readonly store: ConversationJournalStore) {}
-
-	appendPost(command: AppendPostCommand): AppendPostResult {
-		validateAppendPostCommand(command);
-
-		const existing = this.store.findPostByOperationId(command.operationId);
-		if (existing) return { post: existing, replayed: true };
-
-		if (command.replyToPostId !== undefined && !this.store.getPost(command.replyToPostId)) {
-			throw new Error(`replyToPostId "${command.replyToPostId}" not found`);
-		}
-
-		this.store.ensureThread(command.threadId);
-		const { content, truncated } = boundContent(command.content);
-		const post: JournalPost = {
-			id: crypto.randomUUID(),
-			threadId: command.threadId,
-			...(command.replyToPostId !== undefined ? { replyToPostId: command.replyToPostId } : {}),
-			authorId: command.authorId,
-			content,
-			truncated,
-			timestamp: new Date().toISOString(),
-			sourceSessionId: command.sourceSessionId,
-			operationId: command.operationId,
-			references: command.references ? [...command.references] : [],
-		};
-		this.store.insertPost(post);
-		return { post, replayed: false };
-	}
-
-	getThread(threadId: string): JournalThread | undefined {
-		return this.store.getThread(threadId);
-	}
-
-	getPost(id: string): JournalPost | undefined {
-		return this.store.getPost(id);
-	}
-
-	/** Bounded, explicit-completeness thread read. Never silently drops posts past the bound. */
-	readThread(query: ReadThreadQuery): ThreadPage {
-		const limit = query.limit;
-		if (!Number.isInteger(limit) || limit < 1 || limit > CONVERSATION_JOURNAL_READ_MAX_POSTS) {
-			throw new Error(`readThread limit must be between 1 and ${CONVERSATION_JOURNAL_READ_MAX_POSTS}`);
-		}
-		const all = [...this.store.postsForThread(query.threadId)].sort(
-			(left, right) => left.timestamp.localeCompare(right.timestamp) || left.id.localeCompare(right.id),
-		);
-		const truncated = all.length > limit;
-		return { posts: all.slice(0, limit), truncated };
-	}
-
-	/** Reconstructed reply tree for a thread, bounded and orphan/cycle-safe -- see buildThreadTree. */
-	readThreadTree(threadId: string): ThreadTreeNode[] {
-		return buildThreadTree(this.store.postsForThread(threadId));
-	}
-
-	/** Root-first ancestor chain for one post -- the host-neutral equivalent of Pi's getBranch(). */
-	ancestorsOf(postId: string): JournalPost[] {
-		const posts = this.store.postsForThread(this.store.getPost(postId)?.threadId ?? "");
-		const byId = new Map(posts.map((post) => [post.id, post]));
-		return ancestorChain(postId, byId);
-	}
-}

package/src/domain/conversation-journal.ts

@@ -1,168 +0,0 @@
-/**
- * domain/conversation-journal.ts — host-neutral ConversationJournal domain.
- *
- * See decision-discourse-as-a-layer-above-sessions-separate-conver-p832 and
- * pis-tree-implementation-concrete-lessons-for-the-discourse-s-wnrs (Papyrus docs) for the
- * design this implements and the concrete lessons behind each choice below.
- *
- * A Thread is the conversation's own stable identity, independent of whichever host
- * process/session recorded any given Post into it. This module and its package source
- * must never mention host runtime names (no "Pi") -- sourceSessionId is a generic
- * provenance field on a Post, not a host-specific concept, and the host decides what
- * value to put there.
- */
-
-export const CONVERSATION_JOURNAL_CONTENT_MAX_CHARACTERS = 20_000;
-export const CONVERSATION_JOURNAL_SOURCE_ID_MAX_LENGTH = 256;
-export const CONVERSATION_JOURNAL_MAX_REFERENCES_PER_POST = 50;
-/** Bounds a single readThread call; retention/eviction beyond this is a host/persistence concern, not this domain's. */
-export const CONVERSATION_JOURNAL_READ_MAX_POSTS = 500;
-/** Bounds reply-chain traversal so a cycle (accidental or adversarial) cannot infinite-loop a tree build -- see the Pi /tree lessons doc for why this must not be assumed away. */
-export const CONVERSATION_JOURNAL_MAX_TRAVERSAL_DEPTH = 10_000;
-
-export type JournalAuthor = "human" | "agent";
-
-/** A reference to an artifact owned outside this journal -- verified by the host, never asserted. */
-export interface ArtifactReference {
-	readonly kind: string;
-	readonly id: string;
-}
-
-export interface JournalThread {
-	readonly id: string;
-	readonly createdAt: string;
-}
-
-export interface JournalPost {
-	readonly id: string;
-	readonly threadId: string;
-	/** Absent only for a thread's first post. */
-	readonly replyToPostId?: string;
-	readonly authorId: JournalAuthor;
-	readonly content: string;
-	/** True when content was cut to CONVERSATION_JOURNAL_CONTENT_MAX_CHARACTERS -- never silently. */
-	readonly truncated: boolean;
-	readonly timestamp: string;
-	/** Which host session/process recorded this post. Provenance, never this domain's top-level container -- see the layering decision doc. */
-	readonly sourceSessionId: string;
-	/**
-	 * Idempotency key. Must be a composite of (sourceSessionId, a host-local entry id),
-	 * constructed by the caller -- never a bare host entry id alone. A host's own entry
-	 * ids are commonly unique only within one recording session, not globally; using one
-	 * alone as a global idempotency key risks a false dedup collision between two
-	 * unrelated sessions. See the Pi /tree lessons doc for the concrete case this
-	 * generalizes from.
-	 */
-	readonly operationId: string;
-	readonly references: readonly ArtifactReference[];
-}
-
-export interface AppendPostCommand {
-	readonly threadId: string;
-	readonly replyToPostId?: string;
-	readonly authorId: JournalAuthor;
-	readonly content: string;
-	readonly sourceSessionId: string;
-	readonly operationId: string;
-	readonly references?: readonly ArtifactReference[];
-}
-
-export interface AppendPostResult {
-	readonly post: JournalPost;
-	/** True when this exact operationId was already journaled and this call was a safe no-op replay. */
-	readonly replayed: boolean;
-}
-
-export interface ReadThreadQuery {
-	readonly threadId: string;
-	readonly limit: number;
-}
-
-export interface ThreadPage {
-	readonly posts: readonly JournalPost[];
-	/** True when more posts exist beyond `limit` -- never silently drop the tail without saying so. */
-	readonly truncated: boolean;
-}
-
-/** One node of a reconstructed reply tree; see buildThreadTree. */
-export interface ThreadTreeNode {
-	readonly post: JournalPost;
-	readonly children: ThreadTreeNode[];
-}
-
-function requireBounded(value: string, label: string, maxLength: number): string {
-	if (value.length === 0) throw new Error(`${label} is required`);
-	if (value.length > maxLength) throw new Error(`${label} exceeds ${maxLength} characters`);
-	return value;
-}
-
-export function validateAppendPostCommand(command: AppendPostCommand): void {
-	requireBounded(command.threadId, "threadId", CONVERSATION_JOURNAL_SOURCE_ID_MAX_LENGTH);
-	requireBounded(command.sourceSessionId, "sourceSessionId", CONVERSATION_JOURNAL_SOURCE_ID_MAX_LENGTH);
-	requireBounded(command.operationId, "operationId", CONVERSATION_JOURNAL_SOURCE_ID_MAX_LENGTH * 2);
-	if (command.content.length === 0) throw new Error("content is required");
-	if (command.authorId !== "human" && command.authorId !== "agent") throw new Error('authorId must be "human" or "agent"');
-	const references = command.references ?? [];
-	if (references.length > CONVERSATION_JOURNAL_MAX_REFERENCES_PER_POST) {
-		throw new Error(`a post is bounded to ${CONVERSATION_JOURNAL_MAX_REFERENCES_PER_POST} references; got ${references.length}`);
-	}
-}
-
-/** Applies the explicit truncation bound. Never silently drops the truncation fact -- callers must surface `truncated`. */
-export function boundContent(content: string): { content: string; truncated: boolean } {
-	if (content.length <= CONVERSATION_JOURNAL_CONTENT_MAX_CHARACTERS) return { content, truncated: false };
-	return { content: content.slice(0, CONVERSATION_JOURNAL_CONTENT_MAX_CHARACTERS), truncated: true };
-}
-
-/**
- * Reconstructs the reply tree from a flat list of posts (as returned by one bounded
- * readThread call). A post whose replyToPostId does not resolve within this same list --
- * because it is genuinely a thread root, or because an ancestor aged out under a
- * retention policy -- degrades to being treated as a root of its own sub-tree, exactly
- * like Pi's own getTree() treats an orphaned entry. This never throws on that account.
- *
- * Bounded and cycle-safe: a post already visited while walking up cannot be revisited,
- * so a malformed or adversarial replyToPostId cycle cannot infinite-loop this function --
- * see the Pi /tree lessons doc for why that guard must be explicit, not assumed.
- */
-export function buildThreadTree(posts: readonly JournalPost[]): ThreadTreeNode[] {
-	const nodesById = new Map<string, ThreadTreeNode>();
-	for (const post of posts) nodesById.set(post.id, { post, children: [] });
-
-	const roots: ThreadTreeNode[] = [];
-	for (const post of posts) {
-		const node = nodesById.get(post.id)!;
-		const parent = post.replyToPostId ? nodesById.get(post.replyToPostId) : undefined;
-		if (parent) parent.children.push(node);
-		else roots.push(node);
-	}
-
-	for (const node of nodesById.values()) {
-		node.children.sort((left, right) => left.post.timestamp.localeCompare(right.post.timestamp) || left.post.id.localeCompare(right.post.id));
-	}
-	roots.sort((left, right) => left.post.timestamp.localeCompare(right.post.timestamp) || left.post.id.localeCompare(right.post.id));
-	return roots;
-}
-
-/**
- * Walks from a post back toward its thread root via replyToPostId, root-first order --
- * the host-neutral equivalent of Pi's getBranch(). Bounded by
- * CONVERSATION_JOURNAL_MAX_TRAVERSAL_DEPTH and tracks visited ids explicitly so a cycle
- * cannot infinite-loop this walk, unlike Pi's own getBranch() (a documented gap in Pi,
- * not something to assume away here).
- */
-export function ancestorChain(postId: string, postsById: ReadonlyMap<string, JournalPost>): JournalPost[] {
-	const chain: JournalPost[] = [];
-	const visited = new Set<string>();
-	let currentId: string | undefined = postId;
-	while (currentId !== undefined) {
-		if (visited.has(currentId)) break; // cycle guard
-		if (chain.length >= CONVERSATION_JOURNAL_MAX_TRAVERSAL_DEPTH) break; // depth guard
-		visited.add(currentId);
-		const post = postsById.get(currentId);
-		if (!post) break; // orphan: stop here, do not error
-		chain.push(post);
-		currentId = post.replyToPostId;
-	}
-	return chain.reverse();
-}

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"),
-	};
-}

package/src/ports/conversation-journal-store.ts

@@ -1,17 +0,0 @@
-import type { JournalPost, JournalThread } from "../domain/conversation-journal.ts";
-
-/**
- * Persistence port for ConversationJournal. Deliberately minimal and host-neutral: no
- * mention of any host runtime, no query beyond what a bounded thread read needs. Idempotency
- * (checking operationId before insert) is the service's job, not the store's -- this port is
- * dumb storage, matching Discourse's own store/service split (see the layering decision doc).
- */
-export interface ConversationJournalStore {
-	ensureThread(threadId: string): JournalThread;
-	getThread(threadId: string): JournalThread | undefined;
-	findPostByOperationId(operationId: string): JournalPost | undefined;
-	insertPost(post: JournalPost): void;
-	getPost(id: string): JournalPost | undefined;
-	/** All posts for one thread, unbounded at the store layer -- the service applies the read bound. */
-	postsForThread(threadId: string): readonly JournalPost[];
-}