@danypops/papyrus 0.47.1 → 0.48.0

package/src/rules/rules-service.ts

@@ -8,9 +8,14 @@
 import type { Artifact } from "../artifact/artifact.ts";
 import { requireLocallyOwnedContent } from "../artifact/artifact.ts";
 import type { ArtifactEventContext } from "../artifact/artifact-event.ts";
-import type { ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
+import type { ArtifactScope, ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
-import { RULE_TEXT_HARD_LIMIT_CHARACTERS, RULE_TEXT_SOFT_TARGET_CHARACTERS } from "../constants.ts";
+import {
+	ARTIFACT_SCOPE_MAX_PROJECTS_PER_ARTIFACT,
+	RULE_TEXT_HARD_LIMIT_CHARACTERS,
+	RULE_TEXT_SOFT_TARGET_CHARACTERS,
+} from "../constants.ts";
+import { resolveProjectReference } from "../domain/project-registry.ts";
 import { normalizeProjectRoot } from "../domain/task-scope.ts";
 import {
 	assertLabelsBounds,
@@ -24,6 +29,7 @@ import {
 	type TransitionTable,
 	type UpdateContentInput,
 } from "../domain-service-shared.ts";
+import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
 
 export interface CreateRuleInput {
 	title: string;
@@ -36,6 +42,8 @@ export interface CreateRuleInput {
 	extra?: Record<string, unknown>;
 	templateId?: string;
 	projectRoot?: string;
+	/** Bounded exact registered project references (id/name/alias/root) -- fail-closed unlike projectRoot's auto-register-by-root legacy form. Takes precedence over projectRoot when both are given. */
+	projectReferences?: string[];
 }
 
 export type RuleTransition = "enable" | "disable";
@@ -121,8 +129,12 @@ export function createRule(
 	scopes: ArtifactScopeStore,
 	input: CreateRuleInput,
 	context?: ArtifactEventContext,
+	registry?: ProjectRegistryStore,
 ): Artifact {
 	assertRuleTextWithinBounds(input.condition, input.action, input.body);
+	if (input.projectReferences !== undefined && input.projectReferences.length > 0 && registry === undefined) {
+		throw new Error("projectReferences requires a project registry");
+	}
 	const projectRoot = input.projectRoot === undefined ? undefined : normalizeProjectRoot(input.projectRoot);
 	const rule = artifacts.create(
 		{
@@ -143,7 +155,15 @@ export function createRule(
 		},
 		context,
 	);
-	scopes.assign(rule.id, projectRoot, projectRoot === undefined ? "unscoped" : "explicit");
+	if (input.projectReferences !== undefined && input.projectReferences.length > 0) {
+		if (input.projectReferences.length > ARTIFACT_SCOPE_MAX_PROJECTS_PER_ARTIFACT) {
+			throw new Error(`projectReferences may include at most ${ARTIFACT_SCOPE_MAX_PROJECTS_PER_ARTIFACT} entries`);
+		}
+		const ids = input.projectReferences.map((reference) => resolveProjectReference(registry!, reference).id);
+		scopes.replaceProjects(rule.id, ids, "explicit");
+	} else {
+		scopes.assign(rule.id, projectRoot, projectRoot === undefined ? "unscoped" : "explicit");
+	}
 	return rule;
 }
 
@@ -161,22 +181,91 @@ export function assignRuleProject(
 }
 
 /**
- * Global rules always apply; scoped workflow-run rules apply only while their run owns active
- * focus. Both a workflow-definition target's own run scope ("skill-run", written by
- * workflow-execution.ts's runWorkflowSteps for that target kind) and a Playbook's own run scope
- * ("playbook-run", same call for a Playbook target) are recognized -- confirmed live that only
- * "skill-run" was ever checked here, silently breaking Playbook-run-scoped rule injection since
- * Playbook gained its own doc/rule structured steps.
+ * The multi-project scope surface rules.assign_project cannot express (more than one membership,
+ * or exact fail-closed reference resolution instead of assign's auto-register-by-root). id is
+ * resolved through requireKind so these reject the same way against a non-Rule or unknown id as
+ * every other rules.* mutation; the project REFERENCE (name/alias/root) is resolved through the
+ * shared registry's resolveProjectReference, so an unknown or ambiguous project fails closed with
+ * bounded candidates rather than silently creating a new registration or guessing.
+ */
+export function ruleScope(artifacts: ArtifactStore, scopes: ArtifactScopeStore, id: string): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	return scopes.scope(id);
+}
+
+export function setRuleGlobal(artifacts: ArtifactStore, scopes: ArtifactScopeStore, id: string): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	return scopes.setGlobal(id, "explicit");
+}
+
+export function replaceRuleProjects(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	registry: ProjectRegistryStore,
+	id: string,
+	projectReferences: readonly string[],
+): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	if (projectReferences.length === 0) throw new Error("projectReferences must be non-empty; use rules.set_global to clear scoping");
+	if (projectReferences.length > ARTIFACT_SCOPE_MAX_PROJECTS_PER_ARTIFACT) {
+		throw new Error(`projectReferences may include at most ${ARTIFACT_SCOPE_MAX_PROJECTS_PER_ARTIFACT} entries`);
+	}
+	const ids = projectReferences.map((reference) => resolveProjectReference(registry, reference).id);
+	return scopes.replaceProjects(id, ids, "explicit");
+}
+
+export function addRuleProject(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	registry: ProjectRegistryStore,
+	id: string,
+	projectReference: string,
+): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	const project = resolveProjectReference(registry, projectReference);
+	return scopes.addProject(id, project.id, "explicit");
+}
+
+export function removeRuleProject(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	registry: ProjectRegistryStore,
+	id: string,
+	projectReference: string,
+): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	const project = resolveProjectReference(registry, projectReference);
+	return scopes.removeProject(id, project.id);
+}
+
+/** The extra.scope run-gating check alone -- a Rule with no extra.scope always passes this; one with a skill-run/playbook-run scope passes only while its run owns activeTaskId. Both a workflow-definition target's own run scope ("skill-run", written by workflow-execution.ts's runWorkflowSteps for that target kind) and a Playbook's own run scope ("playbook-run", same call for a Playbook target) are recognized -- confirmed live that only "skill-run" was ever checked here, silently breaking Playbook-run-scoped rule injection since Playbook gained its own doc/rule structured steps. */
+function passesRunScope(rule: Artifact, activeTaskId: string | undefined): boolean {
+	const scope = rule.extra.scope;
+	if (scope === undefined) return true;
+	if (typeof scope !== "object" || scope === null || Array.isArray(scope)) return false;
+	const value = scope as Record<string, unknown>;
+	if ((value.type !== "skill-run" && value.type !== "playbook-run") || !Array.isArray(value.taskIds)) return false;
+	return activeTaskId !== undefined && value.taskIds.some((id) => id === activeTaskId);
+}
+
+/**
+ * Global rules always apply everywhere; a project-bound Rule (ArtifactScopeStore's own
+ * project-membership scope, orthogonal to extra.scope's run-gating) is applicable only when
+ * projectRoot resolves to one of its registered project memberships. Both checks are an AND, not
+ * an alternative: extra.scope's own run-gating can no longer bypass project scope, and project
+ * membership can no longer bypass run-gating -- confirmed live that a project-bound Rule was
+ * injected into every project before this fix, since this function never consulted
+ * ArtifactScopeStore at all despite rules.assign_project already existing.
  */
-export function listInjectableRules(artifacts: ArtifactStore, activeTaskId?: string): Artifact[] {
+export function listInjectableRules(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	projectRoot: string | undefined,
+	activeTaskId?: string,
+): Artifact[] {
 	return artifacts.query({ kind: "rule", status: "active" }).filter((rule) => {
 		if (rule.subtype === "artifact-template") return false;
-		const scope = rule.extra.scope;
-		if (scope === undefined) return true;
-		if (typeof scope !== "object" || scope === null || Array.isArray(scope)) return false;
-		const value = scope as Record<string, unknown>;
-		if ((value.type !== "skill-run" && value.type !== "playbook-run") || !Array.isArray(value.taskIds)) return false;
-		return activeTaskId !== undefined && value.taskIds.some((id) => id === activeTaskId);
+		return passesRunScope(rule, activeTaskId) && scopes.appliesToProjectRoot(rule.id, projectRoot);
 	});
 }
 

package/src/service.ts

@@ -4,6 +4,7 @@ import { createVehicleHttpApp } from "@danypops/vehicle-server/http";
 import type { Logger } from "@danypops/vehicle-server/logging";
 import type { CreateArtifactInput } from "./artifact/artifact.ts";
 import type { ArtifactEventReader } from "./artifact/artifact-event-reader.ts";
+import type { ArtifactScopeStore } from "./artifact/artifact-scope-store.ts";
 import type { ArtifactStore } from "./artifact/artifact-store.ts";
 import { removeArtifactSubtree } from "./artifact/artifact-subtree.ts";
 import type { ArtifactTrashStore } from "./artifact/artifact-trash-store.ts";
@@ -38,6 +39,7 @@ 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";
@@ -216,6 +218,7 @@ function handlers(
 	_notes: Notes,
 	_events: TaskEventStore,
 	_scopes: TaskScopeStore,
+	artifactScopes: ArtifactScopeStore,
 	migrate: () => unknown,
 	moduleRegistry: OperationRegistry,
 	authority: AuthorityRegistry,
@@ -345,8 +348,12 @@ function handlers(
 			const id = string(input, "id");
 			return artifacts.get(id)?.kind === "task" ? tasks.runGates(id, eventContextFor(input, "gates-api")) : gates.runAsync(id);
 		},
-		"rules.injectable": (input) =>
-			listInjectableRules(artifacts, tasks.active(taskFilter(input))?.id).map(({ id, title, body, extra }) => ({ id, title, body, extra })),
+		"rules.injectable": (input) => {
+			const filter = taskFilter(input);
+			return listInjectableRules(artifacts, artifactScopes, filter.projectRoot, tasks.active(filter)?.id).map(
+				({ id, title, body, extra }) => ({ id, title, body, extra }),
+			);
+		},
 		"tasks.create": forwardToModule("tasks.create"),
 		"tasks.update": forwardToModule("tasks.update"),
 		"tasks.list": forwardToModule("tasks.list"),
@@ -414,6 +421,11 @@ function handlers(
 		"rules.disable": forwardToModule("rules.disable"),
 		"rules.gate": forwardToModule("rules.gate"),
 		"rules.assign_project": forwardToModule("rules.assign_project"),
+		"rules.scope": forwardToModule("rules.scope"),
+		"rules.set_global": forwardToModule("rules.set_global"),
+		"rules.add_project": forwardToModule("rules.add_project"),
+		"rules.remove_project": forwardToModule("rules.remove_project"),
+		"rules.replace_projects": forwardToModule("rules.replace_projects"),
 		"rules.update": forwardToModule("rules.update"),
 		"playbooks.create": forwardToModule("playbooks.create"),
 		"playbooks.list": forwardToModule("playbooks.list"),
@@ -462,6 +474,7 @@ export function createPapyrusService(path: string): PapyrusService {
 	const notes = new Notes(artifacts, noteEvents);
 	const projections = new SQLiteGraphProjectionStore(db);
 	const artifactScopes = new SQLiteArtifactScopeStore(db);
+	const projectRegistry = new SQLiteProjectRegistryStore(db);
 	const logs = new Logs(new SQLiteLogStore(db));
 	const sessionIdentity = new SessionIdentity(new SQLiteSessionIdentityStore(db));
 	const discussions = new Discussions(artifacts, new SQLiteDiscussionRoundStore(db));
@@ -476,6 +489,7 @@ export function createPapyrusService(path: string): PapyrusService {
 		tasks,
 		discussions,
 		sessionIdentity,
+		projectRegistry,
 	});
 	const moduleRegistry = new OperationRegistry();
 	moduleRegistry.registerAll(notesOperations(notes));
@@ -484,10 +498,10 @@ export function createPapyrusService(path: string): PapyrusService {
 	moduleRegistry.registerAll(discussOperations(discussions));
 	moduleRegistry.registerAll(tasksOperations(tasks, artifacts, sessionIdentity));
 	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority));
-	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes));
+	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes, projectRegistry));
 	moduleRegistry.registerAll(playbooksOperations({ artifacts, events, scopes, artifactScopes, tasks, sessionIdentity }));
 	moduleRegistry.registerAll(graphProjectionOperations(artifacts, projections, authority));
-	const registry = handlers(artifacts, gates, tasks, notes, events, scopes, () => migrateDb(db), moduleRegistry, authority);
+	const registry = handlers(artifacts, gates, tasks, notes, events, scopes, artifactScopes, () => migrateDb(db), moduleRegistry, authority);
 	const state = (): SchemaState => {
 		const current = schemaVersion(db);
 		return { current, required: SQLITE_SCHEMA_VERSION, migrationRequired: current !== SQLITE_SCHEMA_VERSION };

package/src/stores/in-memory-project-registry-store.ts

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { TASK_PROJECT_ALIAS_MAX_COUNT } from "../constants.ts";
+import type { Project, RegisterProjectInput } from "../domain/project-registry.ts";
+import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+
+export function uniqueAliases(values: readonly string[], name: string): string[] {
+	const seen = new Set([name.trim().toLowerCase()]);
+	const aliases = values.flatMap((value) => {
+		const trimmed = value.trim();
+		const key = trimmed.toLowerCase();
+		if (!trimmed || seen.has(key)) return [];
+		seen.add(key);
+		return [trimmed];
+	});
+	if (aliases.length > TASK_PROJECT_ALIAS_MAX_COUNT) {
+		throw new Error(`project aliases cannot exceed ${TASK_PROJECT_ALIAS_MAX_COUNT} entries`);
+	}
+	return aliases;
+}
+
+/**
+ * Extracted from what was TaskScopeStore's own project-registry bookkeeping (project list/exact
+ * resolve/register/rename/move) -- moving a registered project's root must rewrite every
+ * consumer's own rows keyed by that root (Task's own TaskProjectScope/TaskViewPreference,
+ * and independently an ArtifactScopeStore's own membership rows), and more than one consumer
+ * can share a single registry instance specifically so they resolve against identical project
+ * identities. subscribeRootMoved supports that: every subscriber is notified, not just the
+ * first, so sharing one instance across TaskScopeStore and ArtifactScopeStore never silently
+ * drops the other's rewrite.
+ */
+export class InMemoryProjectRegistryStore implements ProjectRegistryStore {
+	private readonly projectRows = new Map<string, Project>();
+	private readonly rootMovedListeners: Array<(previousRoot: string, nextRoot: string) => void> = [];
+
+	subscribeRootMoved(listener: (previousRoot: string, nextRoot: string) => void): void {
+		this.rootMovedListeners.push(listener);
+	}
+
+	projects(query: string | undefined, limit: number): Project[] {
+		const needle = query?.trim().toLowerCase();
+		return [...this.projectRows.values()]
+			.filter(
+				(project) =>
+					!needle ||
+					project.name.toLowerCase().includes(needle) ||
+					project.projectRoot.toLowerCase().includes(needle) ||
+					project.aliases.some((alias) => alias.toLowerCase().includes(needle)),
+			)
+			.sort((left, right) => left.name.localeCompare(right.name) || left.projectRoot.localeCompare(right.projectRoot))
+			.slice(0, limit);
+	}
+
+	matchingProjects(reference: string): Project[] {
+		const needle = reference.trim().toLowerCase();
+		return [...this.projectRows.values()]
+			.filter(
+				(project) =>
+					project.id.toLowerCase() === needle ||
+					project.name.toLowerCase() === needle ||
+					project.projectRoot.toLowerCase() === needle ||
+					project.aliases.some((alias) => alias.toLowerCase() === needle),
+			)
+			.slice(0, 11);
+	}
+
+	registerProject(input: RegisterProjectInput): Project {
+		const now = new Date().toISOString();
+		const byRoot = [...this.projectRows.values()].find((project) => project.projectRoot === input.projectRoot);
+		const existing = input.existingId ? this.projectRows.get(input.existingId) : byRoot;
+		const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
+		const aliases = uniqueAliases(
+			[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
+			name,
+		);
+		const project: Project = {
+			id: existing?.id ?? randomUUID(),
+			name,
+			aliases,
+			projectRoot: input.projectRoot,
+			createdAt: existing?.createdAt ?? now,
+			updatedAt: now,
+		};
+		if (existing && existing.projectRoot !== project.projectRoot) {
+			for (const listener of this.rootMovedListeners) listener(existing.projectRoot, project.projectRoot);
+		}
+		this.projectRows.set(project.id, project);
+		return project;
+	}
+
+	/** Exposed for a caller (e.g. InMemoryTaskScopeStore) that needs to look up a project by its exact current root without going through the bounded matchingProjects search. */
+	byRoot(projectRoot: string): Project | undefined {
+		return [...this.projectRows.values()].find((project) => project.projectRoot === projectRoot);
+	}
+
+	/** Exposed for a caller (e.g. InMemoryArtifactScopeStore) that needs a project's own current fields (its root, for the legacy single-root compatibility view) from a stored membership id, without going through the needle-matching matchingProjects search. */
+	byId(id: string): Project | undefined {
+		return this.projectRows.get(id);
+	}
+}

package/src/stores/sqlite-project-registry-store.ts

@@ -0,0 +1,132 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import type { Project, RegisterProjectInput } from "../domain/project-registry.ts";
+import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+import { uniqueAliases } from "./in-memory-project-registry-store.ts";
+
+interface ProjectRow {
+	id: string;
+	name: string;
+	aliases_json: string;
+	project_root: string;
+	created_at: string;
+	updated_at: string;
+}
+
+function projectFromRow(row: ProjectRow): Project {
+	return {
+		id: row.id,
+		name: row.name,
+		aliases: JSON.parse(row.aliases_json) as string[],
+		projectRoot: row.project_root,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+	};
+}
+
+/**
+ * Backed by `task_projects` -- the same table name Task's own migration (v26) established --
+ * kept as-is rather than renamed, so an existing database's registered project ids/names/roots
+ * survive this extraction with zero migration. Kind-neutral in behavior: nothing here reads or
+ * writes a Task-shaped row: onRootMoved lets a composing store (TaskScopeStore,
+ * ArtifactScopeStore) react to a root move for its own kind-specific rows in the same
+ * transaction, without this store needing to know either of them exist.
+ */
+export class SQLiteProjectRegistryStore implements ProjectRegistryStore {
+	constructor(
+		private readonly db: Db,
+		private readonly onRootMoved?: (db: Db, previousRoot: string, nextRoot: string) => void,
+	) {}
+
+	projects(query: string | undefined, limit: number): Project[] {
+		const needle = query?.trim().toLowerCase();
+		if (!needle) {
+			return (
+				this.db
+					.prepare(
+						"SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects ORDER BY name, project_root LIMIT ?",
+					)
+					.all(limit) as ProjectRow[]
+			).map(projectFromRow);
+		}
+		return (
+			this.db
+				.prepare(`
+					SELECT id, name, aliases_json, project_root, created_at, updated_at
+					FROM task_projects
+					WHERE instr(lower(name), ?) > 0
+						OR instr(lower(project_root), ?) > 0
+						OR EXISTS (
+							SELECT 1 FROM json_each(task_projects.aliases_json)
+							WHERE instr(lower(CAST(json_each.value AS TEXT)), ?) > 0
+						)
+					ORDER BY name, project_root
+					LIMIT ?
+				`)
+				.all(needle, needle, needle, limit) as ProjectRow[]
+		).map(projectFromRow);
+	}
+
+	matchingProjects(reference: string): Project[] {
+		const needle = reference.trim().toLowerCase();
+		return (
+			this.db
+				.prepare(`
+					SELECT id, name, aliases_json, project_root, created_at, updated_at
+					FROM task_projects
+					WHERE lower(id) = ? OR lower(name) = ? OR lower(project_root) = ?
+						OR EXISTS (
+							SELECT 1 FROM json_each(task_projects.aliases_json)
+							WHERE lower(CAST(json_each.value AS TEXT)) = ?
+						)
+					ORDER BY name, project_root
+					LIMIT 11
+				`)
+				.all(needle, needle, needle, needle) as ProjectRow[]
+		).map(projectFromRow);
+	}
+
+	registerProject(input: RegisterProjectInput): Project {
+		return inTransaction(this.db, () => {
+			const row = (
+				input.existingId
+					? this.db
+							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE id = ?")
+							.get(input.existingId)
+					: this.db
+							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE project_root = ?")
+							.get(input.projectRoot)
+			) as ProjectRow | null;
+			const existing = row ? projectFromRow(row) : undefined;
+			const now = new Date().toISOString();
+			const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
+			const aliases = uniqueAliases(
+				[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
+				name,
+			);
+			const project: Project = {
+				id: existing?.id ?? randomUUID(),
+				name,
+				aliases,
+				projectRoot: input.projectRoot,
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now,
+			};
+			if (existing && existing.projectRoot !== project.projectRoot) this.onRootMoved?.(this.db, existing.projectRoot, project.projectRoot);
+			this.db
+				.prepare(`
+					INSERT INTO task_projects (id, name, aliases_json, project_root, created_at, updated_at)
+					VALUES (?, ?, ?, ?, ?, ?)
+					ON CONFLICT(id) DO UPDATE SET
+						name = excluded.name,
+						aliases_json = excluded.aliases_json,
+						project_root = excluded.project_root,
+						updated_at = excluded.updated_at
+				`)
+				.run(project.id, project.name, JSON.stringify(project.aliases), project.projectRoot, project.createdAt, project.updatedAt);
+			return project;
+		});
+	}
+}

package/src/stores/sqlite-task-scope-store.ts

@@ -1,6 +1,3 @@
-import { randomUUID } from "node:crypto";
-import { basename } from "node:path";
-import { TASK_PROJECT_ALIAS_MAX_COUNT } from "../constants.ts";
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
 import type {
@@ -11,45 +8,21 @@ import type {
 	TaskViewMode,
 	TaskViewPreference,
 } from "../domain/task-scope.ts";
+import { SQLiteProjectRegistryStore } from "./sqlite-project-registry-store.ts";
 import type { TaskScopeStore } from "./task-scope-store.ts";
 
-interface ProjectRow {
-	id: string;
-	name: string;
-	aliases_json: string;
-	project_root: string;
-	created_at: string;
-	updated_at: string;
+/** Rewrites every task_scopes/task_views row pinned to a project root that just moved -- called inside the same registerProject() transaction, so a rename/move is atomic with the rewrite. */
+function rewriteTaskRowsForMovedRoot(db: Db, previousRoot: string, nextRoot: string): void {
+	db.prepare("UPDATE task_scopes SET project_root = ? WHERE project_root = ?").run(nextRoot, previousRoot);
+	db.prepare("UPDATE task_views SET project_root = ? WHERE project_root = ?").run(nextRoot, previousRoot);
 }
 
-function projectFromRow(row: ProjectRow): TaskProject {
-	return {
-		id: row.id,
-		name: row.name,
-		aliases: JSON.parse(row.aliases_json) as string[],
-		projectRoot: row.project_root,
-		createdAt: row.created_at,
-		updatedAt: row.updated_at,
-	};
-}
+export class SQLiteTaskScopeStore implements TaskScopeStore {
+	private readonly registry: SQLiteProjectRegistryStore;
 
-function uniqueAliases(values: readonly string[], name: string): string[] {
-	const seen = new Set([name.trim().toLowerCase()]);
-	const aliases = values.flatMap((value) => {
-		const trimmed = value.trim();
-		const key = trimmed.toLowerCase();
-		if (!trimmed || seen.has(key)) return [];
-		seen.add(key);
-		return [trimmed];
-	});
-	if (aliases.length > TASK_PROJECT_ALIAS_MAX_COUNT) {
-		throw new Error(`project aliases cannot exceed ${TASK_PROJECT_ALIAS_MAX_COUNT} entries`);
+	constructor(private readonly db: Db) {
+		this.registry = new SQLiteProjectRegistryStore(db, rewriteTaskRowsForMovedRoot);
 	}
-	return aliases;
-}
-
-export class SQLiteTaskScopeStore implements TaskScopeStore {
-	constructor(private readonly db: Db) {}
 
 	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
 		inTransaction(this.db, () => {
@@ -115,95 +88,14 @@ export class SQLiteTaskScopeStore implements TaskScopeStore {
 	}
 
 	projects(query: string | undefined, limit: number): TaskProject[] {
-		const needle = query?.trim().toLowerCase();
-		if (!needle) {
-			return (
-				this.db
-					.prepare(
-						"SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects ORDER BY name, project_root LIMIT ?",
-					)
-					.all(limit) as ProjectRow[]
-			).map(projectFromRow);
-		}
-		return (
-			this.db
-				.prepare(`
-					SELECT id, name, aliases_json, project_root, created_at, updated_at
-					FROM task_projects
-					WHERE instr(lower(name), ?) > 0
-						OR instr(lower(project_root), ?) > 0
-						OR EXISTS (
-							SELECT 1 FROM json_each(task_projects.aliases_json)
-							WHERE instr(lower(CAST(json_each.value AS TEXT)), ?) > 0
-						)
-					ORDER BY name, project_root
-					LIMIT ?
-				`)
-				.all(needle, needle, needle, limit) as ProjectRow[]
-		).map(projectFromRow);
+		return this.registry.projects(query, limit);
 	}
 
 	matchingProjects(reference: string): TaskProject[] {
-		const needle = reference.trim().toLowerCase();
-		return (
-			this.db
-				.prepare(`
-					SELECT id, name, aliases_json, project_root, created_at, updated_at
-					FROM task_projects
-					WHERE lower(id) = ? OR lower(name) = ? OR lower(project_root) = ?
-						OR EXISTS (
-							SELECT 1 FROM json_each(task_projects.aliases_json)
-							WHERE lower(CAST(json_each.value AS TEXT)) = ?
-						)
-					ORDER BY name, project_root
-					LIMIT 11
-				`)
-				.all(needle, needle, needle, needle) as ProjectRow[]
-		).map(projectFromRow);
+		return this.registry.matchingProjects(reference);
 	}
 
 	registerProject(input: RegisterTaskProjectInput): TaskProject {
-		return inTransaction(this.db, () => {
-			const row = (
-				input.existingId
-					? this.db
-							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE id = ?")
-							.get(input.existingId)
-					: this.db
-							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE project_root = ?")
-							.get(input.projectRoot)
-			) as ProjectRow | null;
-			const existing = row ? projectFromRow(row) : undefined;
-			const now = new Date().toISOString();
-			const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
-			const aliases = uniqueAliases(
-				[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
-				name,
-			);
-			const project: TaskProject = {
-				id: existing?.id ?? randomUUID(),
-				name,
-				aliases,
-				projectRoot: input.projectRoot,
-				createdAt: existing?.createdAt ?? now,
-				updatedAt: now,
-			};
-			if (existing && existing.projectRoot !== project.projectRoot) {
-				this.db.prepare("UPDATE task_scopes SET project_root = ? WHERE project_root = ?").run(project.projectRoot, existing.projectRoot);
-				this.db.prepare("UPDATE task_views SET project_root = ? WHERE project_root = ?").run(project.projectRoot, existing.projectRoot);
-			}
-			this.db
-				.prepare(`
-					INSERT INTO task_projects (id, name, aliases_json, project_root, created_at, updated_at)
-					VALUES (?, ?, ?, ?, ?, ?)
-					ON CONFLICT(id) DO UPDATE SET
-						name = excluded.name,
-						aliases_json = excluded.aliases_json,
-						project_root = excluded.project_root,
-						updated_at = excluded.updated_at
-				`)
-				.run(project.id, project.name, JSON.stringify(project.aliases), project.projectRoot, project.createdAt, project.updatedAt);
-			return project;
-		});
+		return this.registry.registerProject(input);
 	}
 }