@danypops/papyrus 0.55.0 → 0.57.0

package/src/scope-group/in-memory-scope-group-store.ts

@@ -0,0 +1,173 @@
+import { randomUUID } from "node:crypto";
+import { SCOPE_GROUP_MAX_MEMBERS, SCOPE_GROUP_MAX_NESTING_DEPTH } from "../constants.ts";
+import {
+	assertRegisterScopeGroupInputBounds,
+	type RegisterScopeGroupInput,
+	type ScopeGroup,
+	ScopeGroupInUseError,
+	type ScopeMemberRef,
+	sameScopeMember,
+} from "./scope-group.ts";
+import type { ScopeGroupStore } from "./scope-group-store.ts";
+
+interface Row {
+	group: ScopeGroup;
+	members: ScopeMemberRef[];
+}
+
+export class InMemoryScopeGroupStore implements ScopeGroupStore {
+	private readonly rows = new Map<string, Row>();
+
+	groups(query: string | undefined, limit: number): ScopeGroup[] {
+		const needle = query?.trim().toLowerCase();
+		return [...this.rows.values()]
+			.map((row) => row.group)
+			.filter(
+				(group) =>
+					!needle || group.name.toLowerCase().includes(needle) || group.aliases.some((alias) => alias.toLowerCase().includes(needle)),
+			)
+			.sort((left, right) => left.name.localeCompare(right.name))
+			.slice(0, limit);
+	}
+
+	matchingGroups(reference: string): ScopeGroup[] {
+		const needle = reference.trim().toLowerCase();
+		return [...this.rows.values()]
+			.map((row) => row.group)
+			.filter(
+				(group) =>
+					group.id.toLowerCase() === needle ||
+					group.name.toLowerCase() === needle ||
+					group.aliases.some((alias) => alias.toLowerCase() === needle),
+			)
+			.slice(0, 11);
+	}
+
+	get(id: string): ScopeGroup | undefined {
+		return this.rows.get(id)?.group;
+	}
+
+	registerGroup(input: RegisterScopeGroupInput): ScopeGroup {
+		assertRegisterScopeGroupInputBounds(input.name, input.aliases);
+		const existing = input.existingId ? this.rows.get(input.existingId) : undefined;
+		const now = new Date().toISOString();
+		const name = input.name?.trim() || existing?.group.name || "unnamed-scope-group";
+		const seen = new Set([name.toLowerCase()]);
+		const aliases = [
+			...(existing?.group.aliases ?? []),
+			...(existing && existing.group.name !== name ? [existing.group.name] : []),
+			...(input.aliases ?? []),
+		].flatMap((value) => {
+			const trimmed = value.trim();
+			const key = trimmed.toLowerCase();
+			if (!trimmed || seen.has(key)) return [];
+			seen.add(key);
+			return [trimmed];
+		});
+		const group: ScopeGroup = {
+			id: existing?.group.id ?? randomUUID(),
+			name,
+			aliases,
+			createdAt: existing?.group.createdAt ?? now,
+			updatedAt: now,
+		};
+		this.rows.set(group.id, { group, members: existing?.members ?? [] });
+		return group;
+	}
+
+	members(groupId: string): ScopeMemberRef[] {
+		return [...(this.rows.get(groupId)?.members ?? [])];
+	}
+
+	private requireRow(groupId: string): Row {
+		const row = this.rows.get(groupId);
+		if (!row) throw new Error(`scope group "${groupId}" not found`);
+		return row;
+	}
+
+	wouldCreateCycle(groupId: string, candidateMemberGroupId: string): boolean {
+		if (groupId === candidateMemberGroupId) return true;
+		const visited = new Set<string>();
+		const stack = [candidateMemberGroupId];
+		while (stack.length > 0) {
+			const current = stack.pop()!;
+			if (current === groupId) return true;
+			if (visited.has(current)) continue;
+			visited.add(current);
+			for (const member of this.rows.get(current)?.members ?? []) {
+				if (member.type === "group") stack.push(member.id);
+			}
+		}
+		return false;
+	}
+
+	private depthOf(groupId: string, seen: Set<string> = new Set()): number {
+		if (seen.has(groupId)) return 0;
+		seen.add(groupId);
+		const members = this.rows.get(groupId)?.members ?? [];
+		let max = 0;
+		for (const member of members) {
+			if (member.type === "group") max = Math.max(max, 1 + this.depthOf(member.id, seen));
+		}
+		return max;
+	}
+
+	addMember(groupId: string, member: ScopeMemberRef): ScopeGroup {
+		const row = this.requireRow(groupId);
+		if (row.members.some((existing) => sameScopeMember(existing, member))) return row.group;
+		if (row.members.length >= SCOPE_GROUP_MAX_MEMBERS)
+			throw new Error(`a scope group cannot have more than ${SCOPE_GROUP_MAX_MEMBERS} members`);
+		if (member.type === "group") {
+			if (this.wouldCreateCycle(groupId, member.id))
+				throw new Error(`adding "${member.id}" to "${groupId}" would create a scope group cycle`);
+			if (1 + this.depthOf(member.id) > SCOPE_GROUP_MAX_NESTING_DEPTH) {
+				throw new Error(`scope group nesting cannot exceed ${SCOPE_GROUP_MAX_NESTING_DEPTH} levels`);
+			}
+		}
+		row.members.push(member);
+		row.group = { ...row.group, updatedAt: new Date().toISOString() };
+		return row.group;
+	}
+
+	removeMember(groupId: string, member: ScopeMemberRef): ScopeGroup {
+		const row = this.requireRow(groupId);
+		const next = row.members.filter((existing) => !sameScopeMember(existing, member));
+		if (next.length !== row.members.length) {
+			row.members = next;
+			row.group = { ...row.group, updatedAt: new Date().toISOString() };
+		}
+		return row.group;
+	}
+
+	expandToProjectIds(groupId: string): Set<string> {
+		const result = new Set<string>();
+		const visited = new Set<string>();
+		const stack = [groupId];
+		while (stack.length > 0) {
+			const current = stack.pop()!;
+			if (visited.has(current)) continue;
+			visited.add(current);
+			for (const member of this.rows.get(current)?.members ?? []) {
+				if (member.type === "project") result.add(member.id);
+				else stack.push(member.id);
+			}
+		}
+		return result;
+	}
+
+	/** Exposed for a caller (e.g. an ArtifactScopeStore checking whether a group it references still exists) needing raw existence, without going through a bounded search. */
+	exists(groupId: string): boolean {
+		return this.rows.has(groupId);
+	}
+
+	/** Only checks self-consistency (another group's own membership) -- whether any Doc/Rule/Playbook's own explicit scope still references this group is a cross-store concern the caller (deleteScopeGroup, which holds both stores) checks first. */
+	delete(groupId: string): void {
+		for (const [otherId, row] of this.rows) {
+			if (otherId === groupId) continue;
+			if (row.members.some((member) => member.type === "group" && member.id === groupId)) {
+				throw new ScopeGroupInUseError(`scope group "${groupId}" is still a member of scope group "${otherId}"`);
+			}
+		}
+		this.rows.delete(groupId);
+	}
+}

package/src/scope-group/scope-group-store.ts

@@ -0,0 +1,28 @@
+import type { RegisterScopeGroupInput, ScopeGroup, ScopeMemberRef } from "./scope-group.ts";
+
+/**
+ * Kind-neutral registry for named, reusable scope member collections -- the "nesting" primitive
+ * behind an artifact's explicit scope. Mirrors ProjectRegistryStore's own shape (create/list/
+ * matching/register-in-place) plus real membership management and a real delete, learning from
+ * the confirmed-live gap that ProjectRegistryStore itself has no delete path at all (see task
+ * 1716b34b) -- a scope group's own delete refuses while still referenced, rather than never
+ * being possible.
+ */
+export interface ScopeGroupStore {
+	groups(query: string | undefined, limit: number): ScopeGroup[];
+	matchingGroups(reference: string): ScopeGroup[];
+	get(id: string): ScopeGroup | undefined;
+	/** Registers a new group, or renames/updates an existing one in place (via existingId) -- same upsert shape as ProjectRegistryStore.registerProject, minus root-move semantics (a group has no root to move). */
+	registerGroup(input: RegisterScopeGroupInput): ScopeGroup;
+	members(groupId: string): ScopeMemberRef[];
+	/** Adds one member (idempotent). Refuses a group-type member that would create a cycle (directly or transitively) or exceed SCOPE_GROUP_MAX_NESTING_DEPTH, and refuses exceeding SCOPE_GROUP_MAX_MEMBERS. */
+	addMember(groupId: string, member: ScopeMemberRef): ScopeGroup;
+	/** Removes one member (idempotent -- removing an absent member is a no-op). */
+	removeMember(groupId: string, member: ScopeMemberRef): ScopeGroup;
+	/** All projectIds reachable from this group by expanding every nested group member recursively (cycle-safe, depth-bounded), deduplicated. Does not include the group itself. */
+	expandToProjectIds(groupId: string): Set<string>;
+	/** True when adding `candidateMemberGroupId` as a member of `groupId` would create a cycle (groupId is reachable from candidateMemberGroupId) -- checked before addMember persists a group-type member. */
+	wouldCreateCycle(groupId: string, candidateMemberGroupId: string): boolean;
+	/** Deletes a group outright. Refuses (ScopeGroupInUseError) if any artifact's explicit scope or any other group's own membership still references it. */
+	delete(groupId: string): void;
+}

package/src/scope-group/scope-group.ts

@@ -0,0 +1,79 @@
+import { SCOPE_GROUP_ALIAS_MAX_COUNT, SCOPE_GROUP_NAME_MAX_LENGTH } from "../constants.ts";
+
+/**
+ * A named, reusable collection of scope members (registered projects and/or other scope groups)
+ * -- the "explicit scope can include nested scopes" primitive. Lives alongside the project
+ * registry (same shape: id/name/aliases/createdAt/updatedAt) rather than as an Artifact, since
+ * it is bookkeeping infrastructure for scoping, not itself a piece of knowledge or work.
+ *
+ * Deliberately explicit/opt-in membership, not filesystem-path-derived nesting: a registered
+ * project whose root happens to be a subdirectory of another registered project's root is NOT
+ * automatically its child (a real false-positive confirmed live: alignment-lector is registered
+ * under lector/packages/alignment-lector, a subdirectory of lector's own root, but is Lector's
+ * adapter for a *different* project, not part of Lector's own scope). A group's membership is
+ * only ever what was deliberately added to it.
+ */
+export interface ScopeGroup {
+	id: string;
+	name: string;
+	aliases: string[];
+	createdAt: string;
+	updatedAt: string;
+}
+
+/** One member of a ScopeGroup or of an artifact's own explicit scope -- a project, or another group (nesting). */
+export type ScopeMemberRef = { readonly type: "project"; readonly id: string } | { readonly type: "group"; readonly id: string };
+
+export function sameScopeMember(a: ScopeMemberRef, b: ScopeMemberRef): boolean {
+	return a.type === b.type && a.id === b.id;
+}
+
+export interface RegisterScopeGroupInput {
+	name?: string;
+	aliases?: string[];
+	existingId?: string;
+}
+
+export function assertRegisterScopeGroupInputBounds(name: string | undefined, aliases: string[] | undefined): void {
+	if (name !== undefined && (name.trim().length === 0 || name.length > SCOPE_GROUP_NAME_MAX_LENGTH)) {
+		throw new Error(`scope group name must be between 1 and ${SCOPE_GROUP_NAME_MAX_LENGTH} characters`);
+	}
+	if ((aliases?.length ?? 0) > SCOPE_GROUP_ALIAS_MAX_COUNT) {
+		throw new Error(`scope group aliases cannot exceed ${SCOPE_GROUP_ALIAS_MAX_COUNT} entries`);
+	}
+	for (const alias of aliases ?? []) {
+		if (alias.trim().length === 0 || alias.length > SCOPE_GROUP_NAME_MAX_LENGTH) {
+			throw new Error(`each scope group alias must be between 1 and ${SCOPE_GROUP_NAME_MAX_LENGTH} characters`);
+		}
+	}
+}
+
+export class ScopeGroupNotFoundError extends Error {}
+export class ScopeGroupAmbiguousError extends Error {}
+export class ScopeGroupCycleError extends Error {}
+export class ScopeGroupInUseError extends Error {}
+
+export interface ScopeGroupReferenceLookup {
+	matchingGroups(reference: string): ScopeGroup[];
+	groups(query: string | undefined, limit: number): ScopeGroup[];
+}
+
+/** Same bounded, fail-closed exact-reference resolution resolveProjectReference already established -- identical contract, applied to scope groups. */
+export function resolveScopeGroupReference(registry: ScopeGroupReferenceLookup, reference: string): ScopeGroup {
+	const matches = registry.matchingGroups(reference);
+	if (matches.length === 0) {
+		const candidates = registry.groups(reference, 10);
+		const fallback = candidates.length === 0 ? registry.groups(undefined, 10) : candidates;
+		const suffix = fallback.length === 0 ? "" : ` Candidates: ${fallback.map((group) => group.name).join(", ")}`;
+		throw new ScopeGroupNotFoundError(`no scope group named or aliased "${reference}" is registered.${suffix}`);
+	}
+	if (matches.length > 1) {
+		throw new ScopeGroupAmbiguousError(
+			`scope group reference "${reference}" is ambiguous: ${matches
+				.slice(0, 10)
+				.map((group) => group.name)
+				.join(", ")}`,
+		);
+	}
+	return matches[0]!;
+}

package/src/scope-group/sqlite-scope-group-store.ts

@@ -0,0 +1,223 @@
+import { randomUUID } from "node:crypto";
+import { SCOPE_GROUP_MAX_MEMBERS, SCOPE_GROUP_MAX_NESTING_DEPTH } from "../constants.ts";
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import {
+	assertRegisterScopeGroupInputBounds,
+	type RegisterScopeGroupInput,
+	type ScopeGroup,
+	ScopeGroupInUseError,
+	type ScopeMemberRef,
+} from "./scope-group.ts";
+import type { ScopeGroupStore } from "./scope-group-store.ts";
+
+interface GroupRow {
+	id: string;
+	name: string;
+	aliases_json: string;
+	created_at: string;
+	updated_at: string;
+}
+
+function groupFromRow(row: GroupRow): ScopeGroup {
+	return {
+		id: row.id,
+		name: row.name,
+		aliases: JSON.parse(row.aliases_json) as string[],
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+	};
+}
+
+interface MemberRow {
+	member_type: "project" | "group";
+	member_id: string;
+}
+
+function memberFromRow(row: MemberRow): ScopeMemberRef {
+	return row.member_type === "project" ? { type: "project", id: row.member_id } : { type: "group", id: row.member_id };
+}
+
+export class SQLiteScopeGroupStore implements ScopeGroupStore {
+	constructor(private readonly db: Db) {}
+
+	groups(query: string | undefined, limit: number): ScopeGroup[] {
+		const needle = query?.trim().toLowerCase();
+		if (!needle) {
+			return (
+				this.db
+					.prepare("SELECT id, name, aliases_json, created_at, updated_at FROM scope_groups ORDER BY name LIMIT ?")
+					.all(limit) as GroupRow[]
+			).map(groupFromRow);
+		}
+		return (
+			this.db
+				.prepare(`
+					SELECT id, name, aliases_json, created_at, updated_at FROM scope_groups
+					WHERE instr(lower(name), ?) > 0
+						OR EXISTS (SELECT 1 FROM json_each(scope_groups.aliases_json) WHERE instr(lower(CAST(json_each.value AS TEXT)), ?) > 0)
+					ORDER BY name LIMIT ?
+				`)
+				.all(needle, needle, limit) as GroupRow[]
+		).map(groupFromRow);
+	}
+
+	matchingGroups(reference: string): ScopeGroup[] {
+		const needle = reference.trim().toLowerCase();
+		return (
+			this.db
+				.prepare(`
+					SELECT id, name, aliases_json, created_at, updated_at FROM scope_groups
+					WHERE lower(id) = ? OR lower(name) = ?
+						OR EXISTS (SELECT 1 FROM json_each(scope_groups.aliases_json) WHERE lower(CAST(json_each.value AS TEXT)) = ?)
+					LIMIT 11
+				`)
+				.all(needle, needle, needle) as GroupRow[]
+		).map(groupFromRow);
+	}
+
+	get(id: string): ScopeGroup | undefined {
+		const row = this.db
+			.prepare("SELECT id, name, aliases_json, created_at, updated_at FROM scope_groups WHERE id = ?")
+			.get(id) as GroupRow | null;
+		return row ? groupFromRow(row) : undefined;
+	}
+
+	registerGroup(input: RegisterScopeGroupInput): ScopeGroup {
+		assertRegisterScopeGroupInputBounds(input.name, input.aliases);
+		return inTransaction(this.db, () => {
+			const existingRow = input.existingId
+				? (this.db
+						.prepare("SELECT id, name, aliases_json, created_at, updated_at FROM scope_groups WHERE id = ?")
+						.get(input.existingId) as GroupRow | null)
+				: null;
+			const existing = existingRow ? groupFromRow(existingRow) : undefined;
+			const now = new Date().toISOString();
+			const name = input.name?.trim() || existing?.name || "unnamed-scope-group";
+			const seen = new Set([name.toLowerCase()]);
+			const aliases = [
+				...(existing?.aliases ?? []),
+				...(existing && existing.name !== name ? [existing.name] : []),
+				...(input.aliases ?? []),
+			].flatMap((value) => {
+				const trimmed = value.trim();
+				const key = trimmed.toLowerCase();
+				if (!trimmed || seen.has(key)) return [];
+				seen.add(key);
+				return [trimmed];
+			});
+			const group: ScopeGroup = { id: existing?.id ?? randomUUID(), name, aliases, createdAt: existing?.createdAt ?? now, updatedAt: now };
+			this.db
+				.prepare(`
+					INSERT INTO scope_groups (id, name, aliases_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+					ON CONFLICT(id) DO UPDATE SET name = excluded.name, aliases_json = excluded.aliases_json, updated_at = excluded.updated_at
+				`)
+				.run(group.id, group.name, JSON.stringify(group.aliases), group.createdAt, group.updatedAt);
+			return group;
+		});
+	}
+
+	members(groupId: string): ScopeMemberRef[] {
+		return (
+			this.db
+				.prepare("SELECT member_type, member_id FROM scope_group_members WHERE group_id = ? ORDER BY member_type, member_id")
+				.all(groupId) as MemberRow[]
+		).map(memberFromRow);
+	}
+
+	private childGroupIds(groupId: string): string[] {
+		return (
+			this.db.prepare("SELECT member_id FROM scope_group_members WHERE group_id = ? AND member_type = 'group'").all(groupId) as Array<{
+				member_id: string;
+			}>
+		).map((row) => row.member_id);
+	}
+
+	wouldCreateCycle(groupId: string, candidateMemberGroupId: string): boolean {
+		if (groupId === candidateMemberGroupId) return true;
+		const visited = new Set<string>();
+		const stack = [candidateMemberGroupId];
+		while (stack.length > 0) {
+			const current = stack.pop()!;
+			if (current === groupId) return true;
+			if (visited.has(current)) continue;
+			visited.add(current);
+			for (const childId of this.childGroupIds(current)) stack.push(childId);
+		}
+		return false;
+	}
+
+	private depthOf(groupId: string, seen: Set<string> = new Set()): number {
+		if (seen.has(groupId)) return 0;
+		seen.add(groupId);
+		let max = 0;
+		for (const childId of this.childGroupIds(groupId)) max = Math.max(max, 1 + this.depthOf(childId, seen));
+		return max;
+	}
+
+	addMember(groupId: string, member: ScopeMemberRef): ScopeGroup {
+		return inTransaction(this.db, () => {
+			const group = this.get(groupId);
+			if (!group) throw new Error(`scope group "${groupId}" not found`);
+			const already = this.db
+				.prepare("SELECT 1 FROM scope_group_members WHERE group_id = ? AND member_type = ? AND member_id = ?")
+				.get(groupId, member.type, member.id);
+			if (already) return group;
+			const count = (this.db.prepare("SELECT COUNT(*) AS n FROM scope_group_members WHERE group_id = ?").get(groupId) as { n: number }).n;
+			if (count >= SCOPE_GROUP_MAX_MEMBERS) throw new Error(`a scope group cannot have more than ${SCOPE_GROUP_MAX_MEMBERS} members`);
+			if (member.type === "group") {
+				if (this.wouldCreateCycle(groupId, member.id))
+					throw new Error(`adding "${member.id}" to "${groupId}" would create a scope group cycle`);
+				if (1 + this.depthOf(member.id) > SCOPE_GROUP_MAX_NESTING_DEPTH) {
+					throw new Error(`scope group nesting cannot exceed ${SCOPE_GROUP_MAX_NESTING_DEPTH} levels`);
+				}
+			}
+			this.db
+				.prepare("INSERT INTO scope_group_members (group_id, member_type, member_id) VALUES (?, ?, ?)")
+				.run(groupId, member.type, member.id);
+			this.db.prepare("UPDATE scope_groups SET updated_at = ? WHERE id = ?").run(new Date().toISOString(), groupId);
+			return this.get(groupId)!;
+		});
+	}
+
+	removeMember(groupId: string, member: ScopeMemberRef): ScopeGroup {
+		return inTransaction(this.db, () => {
+			const group = this.get(groupId);
+			if (!group) throw new Error(`scope group "${groupId}" not found`);
+			const result = this.db
+				.prepare("DELETE FROM scope_group_members WHERE group_id = ? AND member_type = ? AND member_id = ?")
+				.run(groupId, member.type, member.id);
+			if (result.changes > 0) this.db.prepare("UPDATE scope_groups SET updated_at = ? WHERE id = ?").run(new Date().toISOString(), groupId);
+			return this.get(groupId)!;
+		});
+	}
+
+	expandToProjectIds(groupId: string): Set<string> {
+		const result = new Set<string>();
+		const visited = new Set<string>();
+		const stack = [groupId];
+		while (stack.length > 0) {
+			const current = stack.pop()!;
+			if (visited.has(current)) continue;
+			visited.add(current);
+			for (const member of this.members(current)) {
+				if (member.type === "project") result.add(member.id);
+				else stack.push(member.id);
+			}
+		}
+		return result;
+	}
+
+	/** Only checks self-consistency (another group's own membership) -- whether any Doc/Rule/Playbook's own explicit scope still references this group is a cross-store concern the caller (deleteScopeGroup, which holds both stores) checks first. */
+	delete(groupId: string): void {
+		inTransaction(this.db, () => {
+			const referencingGroup = this.db
+				.prepare("SELECT group_id FROM scope_group_members WHERE member_type = 'group' AND member_id = ? LIMIT 1")
+				.get(groupId) as { group_id: string } | null;
+			if (referencingGroup)
+				throw new ScopeGroupInUseError(`scope group "${groupId}" is still a member of scope group "${referencingGroup.group_id}"`);
+			this.db.prepare("DELETE FROM scope_group_members WHERE group_id = ?").run(groupId);
+			this.db.prepare("DELETE FROM scope_groups WHERE id = ?").run(groupId);
+		});
+	}
+}

package/src/service.ts

@@ -15,11 +15,14 @@ import { type AuthorityClaim, AuthorityRegistry, AuthorizedArtifactWriter } from
 import { SERVICE_MAX_BODY_BYTES, SQLITE_SCHEMA_VERSION } from "./constants.ts";
 import { migrateDb, openDb, schemaVersion } from "./db.ts";
 import { Discussions } from "./discussion/discussion-service.ts";
-import type { TaskEventContext } from "./domain/task-event.ts";
-import type { TaskViewMode } from "./domain/task-scope.ts";
+import { SQLiteDiscussionRoundStore } from "./discussion/sqlite-discussion-round-store.ts";
+import type { GateRunner } from "./gate/gate-runner.ts";
+import { SQLiteGateRunner } from "./gate/sqlite-gate-runner.ts";
+import { SQLiteGraphProjectionStore } from "./graph-projection/sqlite-graph-projection-store.ts";
 import { createPapyrusVehicleRegistry } from "./handlers/registry.ts";
 import { logEvent } from "./log/log.ts";
 import { Logs } from "./log/log-service.ts";
+import { SQLiteLogStore } from "./log/sqlite-log-store.ts";
 import { OperationRegistry } from "./module-registry.ts";
 import { DISCUSS_OPERATION_NAMES, discussOperations } from "./modules/discuss.ts";
 import { DOCS_OPERATION_NAMES, docsOperations } from "./modules/docs.ts";
@@ -30,28 +33,27 @@ import { type OperationInput, optionalNumber, optionalString, string } from "./m
 import { PLAYBOOKS_OPERATION_NAMES, playbooksOperations } from "./modules/playbooks.ts";
 import { PROJECTS_OPERATION_NAMES, projectsOperations } from "./modules/projects.ts";
 import { RULES_OPERATION_NAMES, rulesOperations } from "./modules/rules.ts";
+import { SCOPE_GROUPS_OPERATION_NAMES, scopeGroupsOperations } from "./modules/scope-groups.ts";
 import { SESSION_IDENTITY_OPERATION_NAMES, sessionIdentityOperations } from "./modules/session-identity.ts";
 import { TASKS_OPERATION_NAMES, tasksOperations } from "./modules/tasks.ts";
 import { NOTE_SUBTYPE, Notes } from "./note/note-service.ts";
+import { SQLiteNoteEventStore } from "./note/sqlite-note-event-store.ts";
+import { SQLiteProjectRegistryStore } from "./project-registry/sqlite-project-registry-store.ts";
 import { listInjectableRules } from "./rules/rules-service.ts";
+import { SQLiteScopeGroupStore } from "./scope-group/sqlite-scope-group-store.ts";
 import { InvalidSessionSecretError, SessionIdentity } from "./session-identity/session-identity-service.ts";
-import type { GateRunner } from "./stores/gate-runner.ts";
-import { SQLiteDiscussionRoundStore } from "./stores/sqlite-discussion-round-store.ts";
-import { SQLiteGateRunner } from "./stores/sqlite-gate-runner.ts";
-import { SQLiteGraphProjectionStore } from "./stores/sqlite-graph-projection-store.ts";
-import { SQLiteLogStore } from "./stores/sqlite-log-store.ts";
-import { SQLiteNoteEventStore } from "./stores/sqlite-note-event-store.ts";
-import { SQLiteProjectRegistryStore } from "./stores/sqlite-project-registry-store.ts";
-import { SQLiteSessionIdentityStore } from "./stores/sqlite-session-identity-store.ts";
-import { SQLiteTaskCreateRequestStore } from "./stores/sqlite-task-create-request-store.ts";
-import { SQLiteTaskEventStore } from "./stores/sqlite-task-event-store.ts";
-import { SQLiteTaskFocusStore } from "./stores/sqlite-task-focus-store.ts";
-import { SQLiteTaskLeaseStore } from "./stores/sqlite-task-lease-store.ts";
-import { SQLiteTaskMutationRequestStore } from "./stores/sqlite-task-mutation-request-store.ts";
-import { SQLiteTaskScopeStore } from "./stores/sqlite-task-scope-store.ts";
-import type { TaskEventStore } from "./stores/task-event-store.ts";
-import type { TaskScopeStore } from "./stores/task-scope-store.ts";
+import { SQLiteSessionIdentityStore } from "./session-identity/sqlite-session-identity-store.ts";
 import { type TaskStatus, Tasks } from "./task/task-service.ts";
+import { SQLiteTaskCreateRequestStore } from "./task-create-request/sqlite-task-create-request-store.ts";
+import { SQLiteTaskEventStore } from "./task-event/sqlite-task-event-store.ts";
+import type { TaskEventContext } from "./task-event/task-event.ts";
+import type { TaskEventStore } from "./task-event/task-event-store.ts";
+import { SQLiteTaskFocusStore } from "./task-focus/sqlite-task-focus-store.ts";
+import { SQLiteTaskLeaseStore } from "./task-lease/sqlite-task-lease-store.ts";
+import { SQLiteTaskMutationRequestStore } from "./task-mutation-request/sqlite-task-mutation-request-store.ts";
+import { SQLiteTaskScopeStore } from "./task-scope/sqlite-task-scope-store.ts";
+import type { TaskViewMode } from "./task-scope/task-scope.ts";
+import type { TaskScopeStore } from "./task-scope/task-scope-store.ts";
 import { VERSION } from "./version.ts";
 
 /**
@@ -100,6 +102,7 @@ export const EXPECTED_OPERATION_NAMES = [
 	...RULES_OPERATION_NAMES,
 	...PLAYBOOKS_OPERATION_NAMES,
 	...PROJECTS_OPERATION_NAMES,
+	...SCOPE_GROUPS_OPERATION_NAMES,
 	...GRAPH_PROJECTION_OPERATION_NAMES,
 	...LOGS_OPERATION_NAMES,
 	...SESSION_IDENTITY_OPERATION_NAMES,
@@ -410,9 +413,13 @@ function handlers(
 		"docs.assign_project": forwardToModule("docs.assign_project"),
 		"docs.scope": forwardToModule("docs.scope"),
 		"docs.set_global": forwardToModule("docs.set_global"),
+		"docs.set_none": forwardToModule("docs.set_none"),
 		"docs.add_project": forwardToModule("docs.add_project"),
 		"docs.remove_project": forwardToModule("docs.remove_project"),
 		"docs.replace_projects": forwardToModule("docs.replace_projects"),
+		"docs.add_group": forwardToModule("docs.add_group"),
+		"docs.remove_group": forwardToModule("docs.remove_group"),
+		"docs.replace_groups": forwardToModule("docs.replace_groups"),
 		"docs.update": forwardToModule("docs.update"),
 		"notes.capture": forwardToModule("notes.capture"),
 		"notes.list": forwardToModule("notes.list"),
@@ -431,9 +438,13 @@ function handlers(
 		"rules.assign_project": forwardToModule("rules.assign_project"),
 		"rules.scope": forwardToModule("rules.scope"),
 		"rules.set_global": forwardToModule("rules.set_global"),
+		"rules.set_none": forwardToModule("rules.set_none"),
 		"rules.add_project": forwardToModule("rules.add_project"),
 		"rules.remove_project": forwardToModule("rules.remove_project"),
 		"rules.replace_projects": forwardToModule("rules.replace_projects"),
+		"rules.add_group": forwardToModule("rules.add_group"),
+		"rules.remove_group": forwardToModule("rules.remove_group"),
+		"rules.replace_groups": forwardToModule("rules.replace_groups"),
 		"rules.update": forwardToModule("rules.update"),
 		"playbooks.create": forwardToModule("playbooks.create"),
 		"playbooks.list": forwardToModule("playbooks.list"),
@@ -445,9 +456,13 @@ function handlers(
 		"playbooks.assign_project": forwardToModule("playbooks.assign_project"),
 		"playbooks.scope": forwardToModule("playbooks.scope"),
 		"playbooks.set_global": forwardToModule("playbooks.set_global"),
+		"playbooks.set_none": forwardToModule("playbooks.set_none"),
 		"playbooks.add_project": forwardToModule("playbooks.add_project"),
 		"playbooks.remove_project": forwardToModule("playbooks.remove_project"),
 		"playbooks.replace_projects": forwardToModule("playbooks.replace_projects"),
+		"playbooks.add_group": forwardToModule("playbooks.add_group"),
+		"playbooks.remove_group": forwardToModule("playbooks.remove_group"),
+		"playbooks.replace_groups": forwardToModule("playbooks.replace_groups"),
 		"playbooks.update": forwardToModule("playbooks.update"),
 		"playbooks.contain": forwardToModule("playbooks.contain"),
 		"playbooks.uncontain": forwardToModule("playbooks.uncontain"),
@@ -456,6 +471,13 @@ function handlers(
 		"projects.list": forwardToModule("projects.list"),
 		"projects.resolve": forwardToModule("projects.resolve"),
 		"projects.register": forwardToModule("projects.register"),
+		"scope_groups.list": forwardToModule("scope_groups.list"),
+		"scope_groups.resolve": forwardToModule("scope_groups.resolve"),
+		"scope_groups.register": forwardToModule("scope_groups.register"),
+		"scope_groups.show": forwardToModule("scope_groups.show"),
+		"scope_groups.add_member": forwardToModule("scope_groups.add_member"),
+		"scope_groups.remove_member": forwardToModule("scope_groups.remove_member"),
+		"scope_groups.delete": forwardToModule("scope_groups.delete"),
 		"graph_projection.apply": forwardToModule("graph_projection.apply"),
 		"graph_projection.checkpoint": forwardToModule("graph_projection.checkpoint"),
 		"logs.append": forwardToModule("logs.append"),
@@ -491,6 +513,7 @@ export function createPapyrusService(path: string): PapyrusService {
 	const projections = new SQLiteGraphProjectionStore(db);
 	const artifactScopes = new SQLiteArtifactScopeStore(db);
 	const projectRegistry = new SQLiteProjectRegistryStore(db);
+	const scopeGroups = new SQLiteScopeGroupStore(db);
 	const logs = new Logs(new SQLiteLogStore(db));
 	const sessionIdentity = new SessionIdentity(new SQLiteSessionIdentityStore(db));
 	const discussions = new Discussions(artifacts, new SQLiteDiscussionRoundStore(db));
@@ -506,6 +529,7 @@ export function createPapyrusService(path: string): PapyrusService {
 		discussions,
 		sessionIdentity,
 		projectRegistry,
+		scopeGroups,
 	});
 	const moduleRegistry = new OperationRegistry();
 	moduleRegistry.registerAll(notesOperations(notes));
@@ -513,12 +537,13 @@ export function createPapyrusService(path: string): PapyrusService {
 	moduleRegistry.registerAll(sessionIdentityOperations(sessionIdentity));
 	moduleRegistry.registerAll(discussOperations(discussions));
 	moduleRegistry.registerAll(tasksOperations(tasks, artifacts, sessionIdentity));
-	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority, projectRegistry));
-	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes, projectRegistry));
+	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority, projectRegistry, scopeGroups));
+	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes, projectRegistry, scopeGroups));
 	moduleRegistry.registerAll(
-		playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity, registry: projectRegistry }),
+		playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity, registry: projectRegistry, scopeGroups }),
 	);
 	moduleRegistry.registerAll(projectsOperations(projectRegistry));
+	moduleRegistry.registerAll(scopeGroupsOperations(scopeGroups, projectRegistry, artifactScopes));
 	moduleRegistry.registerAll(graphProjectionOperations(artifacts, projections, authority));
 	const registry = handlers(artifacts, gates, tasks, notes, events, scopes, artifactScopes, () => migrateDb(db), moduleRegistry, authority);
 	const state = (): SchemaState => {

package/src/session-identity/session-identity-service.ts

@@ -4,8 +4,8 @@ import {
 	releaseSessionIdentity,
 	verifySessionSecret,
 } from "@danypops/vehicle-server/session-identity";
-import { assertValidSessionId } from "../domain/session-identity.ts";
-import type { SessionIdentityStore } from "../stores/session-identity-store.ts";
+import { assertValidSessionId } from "./session-identity.ts";
+import type { SessionIdentityStore } from "./session-identity-store.ts";
 
 export interface RegisterSessionIdentityResult {
 	sessionId: string;