@danypops/papyrus 0.11.4 → 0.12.0

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

@@ -0,0 +1,325 @@
+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/adapters/sqlite-graph-projection-store.ts

@@ -0,0 +1,41 @@
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import type { ProjectionCheckpoint } from "../domain/graph-projection.ts";
+import type { GraphProjectionStore } from "../ports/graph-projection-store.ts";
+
+export class SQLiteGraphProjectionStore implements GraphProjectionStore {
+	constructor(private readonly db: Db) {}
+
+	getCheckpoint(producerId: string): ProjectionCheckpoint | null {
+		const row = this.db.prepare("SELECT producer_id, last_sequence, last_batch_id, applied_at FROM graph_projection_checkpoints WHERE producer_id = ?").get(producerId) as
+			| { producer_id: string; last_sequence: number; last_batch_id: string; applied_at: string }
+			| null;
+		if (row == null) return null;
+		return { producerId: row.producer_id, lastSequence: row.last_sequence, lastBatchId: row.last_batch_id, appliedAt: row.applied_at };
+	}
+
+	resolveIdentity(producerId: string, externalId: string): string | undefined {
+		const row = this.db.prepare("SELECT artifact_id FROM graph_projection_identities WHERE producer_id = ? AND external_id = ?").get(producerId, externalId) as
+			| { artifact_id: string }
+			| null;
+		return row?.artifact_id;
+	}
+
+	recordIdentity(producerId: string, externalId: string, artifactId: string): void {
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO graph_projection_identities (producer_id, external_id, artifact_id) VALUES (?, ?, ?)
+				ON CONFLICT(producer_id, external_id) DO UPDATE SET artifact_id = excluded.artifact_id
+			`).run(producerId, externalId, artifactId);
+		});
+	}
+
+	commitCheckpoint(checkpoint: ProjectionCheckpoint): void {
+		inTransaction(this.db, () => {
+			this.db.prepare(`
+				INSERT INTO graph_projection_checkpoints (producer_id, last_sequence, last_batch_id, applied_at) VALUES (?, ?, ?, ?)
+				ON CONFLICT(producer_id) DO UPDATE SET last_sequence = excluded.last_sequence, last_batch_id = excluded.last_batch_id, applied_at = excluded.applied_at
+			`).run(checkpoint.producerId, checkpoint.lastSequence, checkpoint.lastBatchId, checkpoint.appliedAt);
+		});
+	}
+}

package/src/adapters/sqlite-task-focus-store.ts

@@ -1,43 +1,62 @@
+import { TASK_FOCUS_MAX_SCOPES } from "../constants.ts";
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
-import type { TaskFocusState, TaskFocusStatus, TaskFocusStore } from "../ports/task-focus-store.ts";
+import { normalizeFocusScope, type TaskFocusState, type TaskFocusStatus, type TaskFocusStore } from "../ports/task-focus-store.ts";
 
 export class SQLiteTaskFocusStore implements TaskFocusStore {
 	constructor(private readonly db: Db) {}
 
-	get(): TaskFocusState | undefined {
-		const row = this.db.prepare("SELECT task_id, status, pause_reason, updated_at FROM task_focus WHERE scope = 'global'").get() as
+	get(scope?: string): TaskFocusState | undefined {
+		const row = this.db.prepare("SELECT task_id, status, pause_reason, updated_at FROM task_focus WHERE scope = ?").get(normalizeFocusScope(scope)) as
 			| { task_id: string; status: TaskFocusStatus; pause_reason: string | null; updated_at: string }
 			| null;
 		return row ? { taskId: row.task_id, status: row.status, updatedAt: row.updated_at, ...(row.pause_reason ? { pauseReason: row.pause_reason } : {}) } : undefined;
 	}
 
-	set(taskId: string): TaskFocusState { return this.write(taskId, "active"); }
-	pause(taskId: string, reason?: string): TaskFocusState { return this.transition(taskId, "active", "paused", reason); }
-	unpause(taskId: string): TaskFocusState { return this.transition(taskId, "paused", "active"); }
+	set(taskId: string, scope?: string): TaskFocusState { return this.write(taskId, "active", scope); }
+	pause(taskId: string, reason?: string, scope?: string): TaskFocusState { return this.transition(taskId, "active", "paused", reason, scope); }
+	unpause(taskId: string, scope?: string): TaskFocusState { return this.transition(taskId, "paused", "active", undefined, scope); }
 
-	clear(taskId?: string): void {
+	clear(taskId?: string, scope?: string): void {
+		const key = normalizeFocusScope(scope);
 		inTransaction(this.db, () => {
-			if (taskId === undefined) this.db.prepare("DELETE FROM task_focus WHERE scope = 'global'").run();
-			else this.db.prepare("DELETE FROM task_focus WHERE scope = 'global' AND task_id = ?").run(taskId);
+			if (taskId === undefined) this.db.prepare("DELETE FROM task_focus WHERE scope = ?").run(key);
+			else this.db.prepare("DELETE FROM task_focus WHERE scope = ? AND task_id = ?").run(key, taskId);
 		});
 	}
 
-	private transition(taskId: string, expected: TaskFocusStatus, status: TaskFocusStatus, reason?: string): TaskFocusState {
-		const current = this.get();
+	clearEverywhere(taskId: string): void {
+		inTransaction(this.db, () => {
+			this.db.prepare("DELETE FROM task_focus WHERE task_id = ?").run(taskId);
+		});
+	}
+
+	private transition(taskId: string, expected: TaskFocusStatus, status: TaskFocusStatus, reason: string | undefined, scope: string | undefined): TaskFocusState {
+		const current = this.get(scope);
 		if (current?.taskId !== taskId) throw new Error(`task "${taskId}" is not focused`);
 		if (current.status !== expected) throw new Error(`focus is ${current.status}, expected ${expected}`);
-		return this.write(taskId, status, reason);
+		return this.write(taskId, status, scope, reason);
+	}
+
+	/** Bounds distinct concurrent focus scopes (sessions); evicts the least-recently-updated scope beyond the cap. */
+	private evictOldestBeyondCap(key: string): void {
+		const exists = this.db.prepare("SELECT 1 FROM task_focus WHERE scope = ?").get(key);
+		if (exists) return;
+		const count = (this.db.prepare("SELECT COUNT(*) AS count FROM task_focus").get() as { count: number }).count;
+		if (count < TASK_FOCUS_MAX_SCOPES) return;
+		this.db.exec("DELETE FROM task_focus WHERE scope = (SELECT scope FROM task_focus ORDER BY updated_at ASC LIMIT 1)");
 	}
 
-	private write(taskId: string, status: TaskFocusStatus, pauseReason?: string): TaskFocusState {
+	private write(taskId: string, status: TaskFocusStatus, scope: string | undefined, pauseReason?: string): TaskFocusState {
+		const key = normalizeFocusScope(scope);
 		const updatedAt = new Date().toISOString();
 		inTransaction(this.db, () => {
+			this.evictOldestBeyondCap(key);
 			this.db.prepare(`
 				INSERT INTO task_focus (scope, task_id, status, pause_reason, updated_at)
-				VALUES ('global', ?, ?, ?, ?)
+				VALUES (?, ?, ?, ?, ?)
 				ON CONFLICT(scope) DO UPDATE SET task_id = excluded.task_id, status = excluded.status, pause_reason = excluded.pause_reason, updated_at = excluded.updated_at
-			`).run(taskId, status, pauseReason ?? null, updatedAt);
+			`).run(key, taskId, status, pauseReason ?? null, updatedAt);
 		});
 		return { taskId, status, updatedAt, ...(pauseReason ? { pauseReason } : {}) };
 	}

package/src/authority-registry.ts

@@ -0,0 +1,115 @@
+/**
+ * authority-registry.ts — step 4 of the incremental refactor in
+ * reducing-papyrus-consumer-change-amplification-with-modules--pvdo.
+ *
+ * Subtype/relation ownership guards (isDiscourseSubtype, NOTE_SUBTYPE, task-kind checks)
+ * were previously re-implemented at every write call site across src/service.ts and
+ * src/domain-services.ts. This is the one deep enforcement point: a claim expresses
+ * which module owns which artifact kind/subtype or relation and what message a
+ * non-owner gets for a given action; AuthorizedArtifactWriter enforces claims for the
+ * mechanical link/unlink/status paths where the target artifact's persisted kind/subtype
+ * is unambiguous. Create is intentionally NOT wrapped transparently here — template
+ * resolution (an artifact-template's declared targetKind/defaults.subtype) determines
+ * the effective kind/subtype before a claim can be checked, and callers already resolve
+ * that themselves; they call registry.requireArtifactAllowed(...) directly with the
+ * resolved kind/subtype instead.
+ *
+ * This module has no domain knowledge of its own (no Discourse/Notes/Tasks awareness) —
+ * claims are constructed at the composition root (src/service.ts) where that knowledge
+ * already lives, matching "the core has generic registries" from the decision doc.
+ */
+import type { ArtifactEventContext } from "./domain/artifact-event.ts";
+import type { Artifact, ArtifactLink } from "./domain/artifact.ts";
+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". */
+	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;
+	matchesRelation?(relation: string): boolean;
+	/**
+	 * If provided, this claim is only enforced for the given actions — e.g. Task ownership of
+	 * kind="task" is only enforced for status changes; artifact.create redirects kind="task" to
+	 * tasks.create rather than rejecting it, so the claim must not match the "create" action.
+	 * Omit to apply to every action.
+	 */
+	appliesToAction?(action: ArtifactAction): boolean;
+	/** Exact rejection message for a non-owner attempting `action`. Must match the historical per-action wording. */
+	denyMessage(action: ArtifactAction): string;
+}
+
+/** O(N) claims, O(N) lookup (N is the number of registered domains, not artifacts — small and fixed at boot). */
+export class AuthorityRegistry {
+	private readonly claims: AuthorityClaim[] = [];
+
+	claim(claim: AuthorityClaim): void {
+		this.claims.push(claim);
+	}
+
+	claimAll(claims: readonly AuthorityClaim[]): void {
+		for (const entry of claims) this.claim(entry);
+	}
+
+	claimForArtifact(kind: string | undefined, subtype: string | undefined, action: ArtifactAction): AuthorityClaim | undefined {
+		return this.claims.find((entry) => (entry.appliesToAction?.(action) ?? true) && entry.matchesArtifact(kind, subtype));
+	}
+
+	claimForRelation(relation: string, action: ArtifactAction): AuthorityClaim | undefined {
+		return this.claims.find((entry) => (entry.appliesToAction?.(action) ?? true) && entry.matchesRelation?.(relation) === true);
+	}
+
+	/** Throws the owning claim's message if kind/subtype is claimed by a module other than `caller`. No-op if unclaimed or caller is the owner. */
+	requireArtifactAllowed(kind: string | undefined, subtype: string | undefined, action: ArtifactAction, caller: string): void {
+		const claim = this.claimForArtifact(kind, subtype, action);
+		if (claim && claim.owner !== caller) throw new Error(claim.denyMessage(action));
+	}
+
+	requireRelationAllowed(relation: string, action: ArtifactAction, caller: string): void {
+		const claim = this.claimForRelation(relation, action);
+		if (claim && claim.owner !== caller) throw new Error(claim.denyMessage(action));
+	}
+}
+
+/**
+ * A scoped write path bound to one caller identity. Every mutating call re-checks the
+ * *persisted* kind/subtype of the artifacts involved (via a get() read, not a cached
+ * assumption), so a caller cannot bypass a claim by acting on an id whose current
+ * ownership it hasn't verified.
+ */
+export class AuthorizedArtifactWriter {
+	constructor(
+		private readonly store: ArtifactStore,
+		private readonly registry: AuthorityRegistry,
+		private readonly caller: string,
+	) {}
+
+	link(link: ArtifactLink, context?: ArtifactEventContext): void {
+		this.checkLink(link);
+		this.store.link(link, context);
+	}
+
+	unlink(link: ArtifactLink, context?: ArtifactEventContext): boolean {
+		this.checkLink(link);
+		return this.store.unlink(link, context);
+	}
+
+	setStatus(id: string, status: string, context?: ArtifactEventContext): Artifact | null {
+		const artifact = this.store.get(id);
+		if (artifact) this.registry.requireArtifactAllowed(artifact.kind, artifact.subtype, "status", this.caller);
+		return this.store.setStatus(id, status, context);
+	}
+
+	/** Exposed standalone so a caller that needs custom branching between claim-checked and redirect
+	 * paths (e.g. graph.link routing depends_on between two Tasks through Tasks.depend for cycle
+	 * safety) can still run the exact same check before deciding which path to take. */
+	checkLink(link: ArtifactLink): void {
+		this.registry.requireRelationAllowed(link.relation, "link", this.caller);
+		const from = this.store.get(link.from);
+		const to = this.store.get(link.to);
+		if (from) this.registry.requireArtifactAllowed(from.kind, from.subtype, "link", this.caller);
+		if (to) this.registry.requireArtifactAllowed(to.kind, to.subtype, "link", this.caller);
+	}
+}