@danypops/papyrus 0.56.0 → 0.57.0

package/src/modules/rules.ts

@@ -15,24 +15,29 @@ import { type Artifact, summarizeArtifact } from "../artifact/artifact.ts";
 import type { ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
 import type { OperationDefinition } from "../module-registry.ts";
-import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
 import {
+	addRuleGroup,
 	addRuleProject,
 	assignRuleProject,
 	createRule,
 	gateTaskWithRule,
 	listRules,
 	previewRule,
+	removeRuleGroup,
 	removeRuleProject,
+	replaceRuleGroups,
 	replaceRuleProjects,
 	ruleCombinedLength,
 	ruleCombinedLengthWarning,
 	ruleScope,
 	setRuleGlobal,
+	setRuleNone,
 	showRule,
 	transitionRule,
 	updateRule,
 } from "../rules/rules-service.ts";
+import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
 import { type OperationInput, optionalBoolean, optionalNumber, optionalString, string } from "./operation-input.ts";
 
 const MODULE_ID = "rules";
@@ -79,9 +84,13 @@ export const RULES_OPERATION_NAMES = [
 	"rules.assign_project",
 	"rules.scope",
 	"rules.set_global",
+	"rules.set_none",
 	"rules.add_project",
 	"rules.remove_project",
 	"rules.replace_projects",
+	"rules.add_group",
+	"rules.remove_group",
+	"rules.replace_groups",
 	"rules.update",
 ] as const;
 
@@ -89,6 +98,7 @@ export function rulesOperations(
 	artifacts: ArtifactStore,
 	scopes: ArtifactScopeStore,
 	registry: ProjectRegistryStore,
+	scopeGroups: ScopeGroupStore,
 ): OperationDefinition[] {
 	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
 		name,
@@ -144,6 +154,16 @@ export function rulesOperations(
 		),
 		define("rules.scope", (input: OperationInput) => ruleScope(artifacts, scopes, string(input, "id"))),
 		define("rules.set_global", (input: OperationInput) => setRuleGlobal(artifacts, scopes, string(input, "id"))),
+		define("rules.set_none", (input: OperationInput) => setRuleNone(artifacts, scopes, string(input, "id"))),
+		define("rules.add_group", (input: OperationInput) =>
+			addRuleGroup(artifacts, scopes, scopeGroups, string(input, "id"), string(input, "group")),
+		),
+		define("rules.remove_group", (input: OperationInput) =>
+			removeRuleGroup(artifacts, scopes, scopeGroups, string(input, "id"), string(input, "group")),
+		),
+		define("rules.replace_groups", (input: OperationInput) =>
+			replaceRuleGroups(artifacts, scopes, scopeGroups, string(input, "id"), (input.groups as string[] | undefined) ?? []),
+		),
 		define("rules.add_project", (input: OperationInput) =>
 			addRuleProject(artifacts, scopes, registry, string(input, "id"), string(input, "project")),
 		),

package/src/modules/scope-groups.ts

@@ -0,0 +1,92 @@
+/**
+ * modules/scope-groups.ts — named, reusable, possibly-nested scope member collections as their
+ * own Papyrus-native registered module. A scope group's own members (added/removed here) are
+ * referenced by Docs/Rules/Playbooks' own explicit scope (docs/rules/playbooks.add_group etc.,
+ * see ../artifact/artifact-scope-store.ts) -- "explicit scope can include nested scopes".
+ * Mirrors modules/projects.ts's own shape (list/resolve/register) for the catalog half, plus
+ * real membership management and a real delete (deleteScopeGroup, unlike ProjectRegistryStore
+ * which has no delete path at all -- see papyrus task 1716b34b).
+ */
+
+import type { ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
+import { SCOPE_GROUP_LIST_MAX_RESULTS } from "../constants.ts";
+import type { OperationDefinition } from "../module-registry.ts";
+import { resolveProjectReference } from "../project-registry/project-registry.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
+import { deleteScopeGroup } from "../scope-group/delete-scope-group.ts";
+import { resolveScopeGroupReference, type ScopeMemberRef } from "../scope-group/scope-group.ts";
+import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
+import { type OperationInput, optionalNumber, optionalString, optionalStringArray, string } from "./operation-input.ts";
+
+const MODULE_ID = "scope_groups";
+
+export const SCOPE_GROUPS_OPERATION_NAMES = [
+	"scope_groups.list",
+	"scope_groups.resolve",
+	"scope_groups.register",
+	"scope_groups.show",
+	"scope_groups.add_member",
+	"scope_groups.remove_member",
+	"scope_groups.delete",
+] as const;
+
+function resolveMember(
+	registry: ProjectRegistryStore,
+	scopeGroups: ScopeGroupStore,
+	memberType: string,
+	memberReference: string,
+): ScopeMemberRef {
+	if (memberType === "project") return { type: "project", id: resolveProjectReference(registry, memberReference).id };
+	if (memberType === "group") return { type: "group", id: resolveScopeGroupReference(scopeGroups, memberReference).id };
+	throw new Error('member_type must be "project" or "group"');
+}
+
+export function scopeGroupsOperations(
+	scopeGroups: ScopeGroupStore,
+	registry: ProjectRegistryStore,
+	artifactScopes: ArtifactScopeStore,
+): OperationDefinition[] {
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name,
+		moduleId: MODULE_ID,
+		execute,
+	});
+	return [
+		define("scope_groups.list", (input: OperationInput) => {
+			const limit = optionalNumber(input, "limit") ?? 20;
+			if (!Number.isInteger(limit) || limit < 1 || limit > SCOPE_GROUP_LIST_MAX_RESULTS) {
+				throw new Error(`scope group list limit must be between 1 and ${SCOPE_GROUP_LIST_MAX_RESULTS}`);
+			}
+			return scopeGroups.groups(optionalString(input, "query"), limit);
+		}),
+		define("scope_groups.resolve", (input: OperationInput) => resolveScopeGroupReference(scopeGroups, string(input, "reference"))),
+		define("scope_groups.register", (input: OperationInput) =>
+			scopeGroups.registerGroup({
+				name: optionalString(input, "name"),
+				aliases: optionalStringArray(input, "aliases"),
+				existingId: optionalString(input, "existing_id"),
+			}),
+		),
+		define("scope_groups.show", (input: OperationInput) => {
+			const group = resolveScopeGroupReference(scopeGroups, string(input, "group"));
+			return { group, members: scopeGroups.members(group.id) };
+		}),
+		define("scope_groups.add_member", (input: OperationInput) => {
+			const group = resolveScopeGroupReference(scopeGroups, string(input, "group"));
+			const member = resolveMember(registry, scopeGroups, string(input, "member_type"), string(input, "member_reference"));
+			scopeGroups.addMember(group.id, member);
+			return { group, members: scopeGroups.members(group.id) };
+		}),
+		define("scope_groups.remove_member", (input: OperationInput) => {
+			const group = resolveScopeGroupReference(scopeGroups, string(input, "group"));
+			const member = resolveMember(registry, scopeGroups, string(input, "member_type"), string(input, "member_reference"));
+			scopeGroups.removeMember(group.id, member);
+			return { group, members: scopeGroups.members(group.id) };
+		}),
+		define("scope_groups.delete", (input: OperationInput) => {
+			const group = resolveScopeGroupReference(scopeGroups, string(input, "group"));
+			deleteScopeGroup(scopeGroups, artifactScopes, group.id);
+			return { deleted: true, id: group.id };
+		}),
+	];
+}

package/src/modules/tasks.ts

@@ -21,14 +21,14 @@
 
 import { summarizeArtifact } from "../artifact/artifact.ts";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
-import type { Checklist } from "../domain/checklist.ts";
-import type { TaskEventContext, TaskEventDirection, TaskEventFeedQuery } from "../domain/task-event.ts";
-import type { TaskViewMode } from "../domain/task-scope.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import type { SessionIdentity } from "../session-identity/session-identity-service.ts";
+import type { Checklist } from "../task/checklist.ts";
 import { taskContext } from "../task/task-context.ts";
 import { projectTaskExecution } from "../task/task-execution.ts";
 import type { TaskMutationRequestContext, TaskStatus, Tasks } from "../task/task-service.ts";
+import type { TaskEventContext, TaskEventDirection, TaskEventFeedQuery } from "../task-event/task-event.ts";
+import type { TaskViewMode } from "../task-scope/task-scope.ts";
 import { type OperationInput, optionalBoolean, optionalNumber, optionalString, optionalStringArray, string } from "./operation-input.ts";
 
 const MODULE_ID = "tasks";

package/src/{stores → note}/note-event-store.ts

@@ -5,7 +5,7 @@ import {
 	type NoteHistoryQuery,
 	normalizeNoteHistoryQuery,
 	validateNoteEvent,
-} from "../domain/note-event.ts";
+} from "../note/note-event.ts";
 
 export interface NoteEventStore {
 	append(event: AppendNoteEvent): NoteEvent;

package/src/note/note-service.ts

@@ -10,8 +10,8 @@ import {
 	NOTE_TITLE_MAX_CHARACTERS,
 	TASK_PROJECT_ROOT_MAX_LENGTH,
 } from "../constants.ts";
-import type { AppendNoteEvent, NoteEventType, NoteHistoryPage, NoteHistoryQuery } from "../domain/note-event.ts";
-import { InMemoryNoteEventStore, type NoteEventStore } from "../stores/note-event-store.ts";
+import type { AppendNoteEvent, NoteEventType, NoteHistoryPage, NoteHistoryQuery } from "./note-event.ts";
+import { InMemoryNoteEventStore, type NoteEventStore } from "./note-event-store.ts";
 
 export const NOTE_SUBTYPE = "note";
 export const NOTE_DISPOSITIONS = ["completed", "duplicate", "declined", "superseded"] as const;

package/src/{stores → note}/sqlite-note-event-store.ts

@@ -7,8 +7,8 @@ import {
 	type NoteHistoryQuery,
 	normalizeNoteHistoryQuery,
 	validateNoteEvent,
-} from "../domain/note-event.ts";
-import type { NoteEventStore } from "./note-event-store.ts";
+} from "../note/note-event.ts";
+import type { NoteEventStore } from "../note/note-event-store.ts";
 
 interface NoteEventRow {
 	id: number;

package/src/ops.ts

@@ -481,7 +481,7 @@ export function purgeDueArtifacts(db: Db, now: () => string = () => new Date().t
 			db.prepare("DELETE FROM task_scopes WHERE task_id = ?").run(id);
 			db.prepare("DELETE FROM task_views WHERE root_task_id = ?").run(id);
 			db.prepare("DELETE FROM graph_projection_identities WHERE artifact_id = ?").run(id);
-			db.prepare("DELETE FROM artifact_scope_projects WHERE artifact_id = ?").run(id);
+			db.prepare("DELETE FROM artifact_scope_members WHERE artifact_id = ?").run(id);
 			db.prepare("DELETE FROM artifact_scopes WHERE artifact_id = ?").run(id);
 			db.prepare("DELETE FROM task_events WHERE task_id = ?").run(id);
 			db.prepare("DELETE FROM note_events WHERE note_id = ?").run(id);

package/src/playbook/playbook-definition.ts

@@ -33,8 +33,8 @@ import type {
 	DocBlueprint,
 	RuleBlueprint,
 	TaskBlueprint,
-} from "../domain/blueprint-definition.ts";
-import { validateBlueprintDefinition } from "../domain/blueprint-definition.ts";
+} from "./blueprint-definition.ts";
+import { validateBlueprintDefinition } from "./blueprint-definition.ts";
 import type { PlaybookArgument, PlaybookStep } from "./playbook-service.ts";
 
 /** A non-composing edge touching a playbook node, to be mirrored onto that node's generated root task once real task ids exist -- e.g. a Rule `gates` this playbook, or this playbook `references`/`documents` a Doc. Direction is preserved exactly: `from`/`to` name whichever side is NOT the playbook, and `ownerIsFrom` says which side the playbook (now the generated root task) occupies. */

package/src/playbook/playbook-execution.ts

@@ -10,8 +10,8 @@
 
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
 import { requireAtomicArtifactStore } from "../artifact/atomic-artifact-store.ts";
-import type { BlueprintArgumentValue } from "../domain/blueprint-definition.ts";
 import type { TaskExecutionPlan } from "../task/task-execution.ts";
+import type { BlueprintArgumentValue } from "./blueprint-definition.ts";
 import { compilePlaybookDefinition } from "./playbook-definition.ts";
 import {
 	applyPlaybookExternalLinks,

package/src/playbook/playbook-service.ts

@@ -28,7 +28,6 @@ import type { ArtifactEventContext } from "../artifact/artifact-event.ts";
 import type { ArtifactScope, ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
 import {
-	ARTIFACT_SCOPE_MAX_PROJECTS_PER_ARTIFACT,
 	ARTIFACT_TITLE_MAX_LENGTH,
 	PLAYBOOK_ARGUMENT_DESCRIPTION_MAX_LENGTH,
 	PLAYBOOK_ARGUMENT_MAX_COUNT,
@@ -39,26 +38,33 @@ import {
 	SKILL_MAX_ENUM_VALUES,
 } from "../constants.ts";
 import {
-	BLUEPRINT_INPUT_TYPES,
-	type BlueprintArgumentValue,
-	type BlueprintInputType,
-	validateArgumentValue,
-} from "../domain/blueprint-definition.ts";
-import { resolveProjectReference } from "../domain/project-registry.ts";
-import { normalizeProjectRoot } from "../domain/task-scope.ts";
-import {
+	addArtifactScopeGroup,
+	addArtifactScopeProject,
 	assertBodyBounds,
 	assertLabelsBounds,
 	assertTitleBounds,
 	assignArtifactProject,
 	type ListFilter,
 	listScoped,
+	removeArtifactScopeGroup,
+	removeArtifactScopeProject,
+	replaceArtifactScopeGroups,
+	replaceArtifactScopeProjects,
 	requireKind,
 	runTransition,
+	setArtifactScopeNone,
 	type TransitionTable,
 	type UpdateContentInput,
 } from "../domain-service-shared.ts";
-import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
+import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
+import { normalizeProjectRoot } from "../task-scope/task-scope.ts";
+import {
+	BLUEPRINT_INPUT_TYPES,
+	type BlueprintArgumentValue,
+	type BlueprintInputType,
+	validateArgumentValue,
+} from "./blueprint-definition.ts";
 
 export interface PlaybookArgument {
 	name: string;
@@ -280,11 +286,7 @@ export function createPlaybook(
 		context,
 	);
 	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(playbook.id, ids, "explicit");
+		replaceArtifactScopeProjects(scopes, registry!, playbook.id, input.projectReferences);
 	} else {
 		scopes.assign(playbook.id, projectRoot, projectRoot === undefined ? "unscoped" : "explicit");
 	}
@@ -320,7 +322,13 @@ export function playbookScope(artifacts: ArtifactStore, scopes: ArtifactScopeSto
 
 export function setPlaybookGlobal(artifacts: ArtifactStore, scopes: ArtifactScopeStore, id: string): ArtifactScope {
 	requireKind(artifacts, id, "playbook");
-	return scopes.setGlobal(id, "explicit");
+	return scopes.setAll(id, "explicit");
+}
+
+/** Fully hides this Playbook -- never applicable, never injected via before_agent_start, regardless of project. */
+export function setPlaybookNone(artifacts: ArtifactStore, scopes: ArtifactScopeStore, id: string): ArtifactScope {
+	requireKind(artifacts, id, "playbook");
+	return setArtifactScopeNone(scopes, id);
 }
 
 export function replacePlaybookProjects(
@@ -331,12 +339,7 @@ export function replacePlaybookProjects(
 	projectReferences: readonly string[],
 ): ArtifactScope {
 	requireKind(artifacts, id, "playbook");
-	if (projectReferences.length === 0) throw new Error("projectReferences must be non-empty; use playbooks.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");
+	return replaceArtifactScopeProjects(scopes, registry, id, projectReferences);
 }
 
 export function addPlaybookProject(
@@ -347,8 +350,7 @@ export function addPlaybookProject(
 	projectReference: string,
 ): ArtifactScope {
 	requireKind(artifacts, id, "playbook");
-	const project = resolveProjectReference(registry, projectReference);
-	return scopes.addProject(id, project.id, "explicit");
+	return addArtifactScopeProject(scopes, registry, id, projectReference);
 }
 
 export function removePlaybookProject(
@@ -359,8 +361,41 @@ export function removePlaybookProject(
 	projectReference: string,
 ): ArtifactScope {
 	requireKind(artifacts, id, "playbook");
-	const project = resolveProjectReference(registry, projectReference);
-	return scopes.removeProject(id, project.id);
+	return removeArtifactScopeProject(scopes, registry, id, projectReference);
+}
+
+/** Scope-group ('nested scope') siblings of replacePlaybookProjects/addPlaybookProject/removePlaybookProject. */
+export function replacePlaybookGroups(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	scopeGroups: ScopeGroupStore,
+	id: string,
+	groupReferences: readonly string[],
+): ArtifactScope {
+	requireKind(artifacts, id, "playbook");
+	return replaceArtifactScopeGroups(scopes, scopeGroups, id, groupReferences);
+}
+
+export function addPlaybookGroup(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	scopeGroups: ScopeGroupStore,
+	id: string,
+	groupReference: string,
+): ArtifactScope {
+	requireKind(artifacts, id, "playbook");
+	return addArtifactScopeGroup(scopes, scopeGroups, id, groupReference);
+}
+
+export function removePlaybookGroup(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	scopeGroups: ScopeGroupStore,
+	id: string,
+	groupReference: string,
+): ArtifactScope {
+	requireKind(artifacts, id, "playbook");
+	return removeArtifactScopeGroup(scopes, scopeGroups, id, groupReference);
 }
 
 export function showPlaybook(artifacts: ArtifactStore, id: string): Artifact {

package/src/playbook/workflow-execution.ts

@@ -9,20 +9,20 @@ import {
 	SKILL_WORKFLOW_MAX_NESTING_DEPTH,
 	TASK_EXECUTION_MAX_EDGES,
 } from "../constants.ts";
+import { validateChecklist } from "../task/checklist.ts";
+import { projectTaskExecution, TaskExecutionBoundExceededError, type TaskExecutionPlan } from "../task/task-execution.ts";
+import type { TaskGraph, TaskNode, TaskStatus } from "../task/task-service.ts";
+import type { TaskEventContext } from "../task-event/task-event.ts";
+import type { TaskEventStore } from "../task-event/task-event-store.ts";
+import { normalizeProjectRoot } from "../task-scope/task-scope.ts";
+import type { TaskScopeStore } from "../task-scope/task-scope-store.ts";
 import {
 	type BlueprintArgumentValue,
 	type BlueprintDefinition,
 	type CallBlueprint,
 	resolveBlueprintArguments,
 	validateBlueprintDefinition,
-} from "../domain/blueprint-definition.ts";
-import { validateChecklist } from "../domain/checklist.ts";
-import type { TaskEventContext } from "../domain/task-event.ts";
-import { normalizeProjectRoot } from "../domain/task-scope.ts";
-import type { TaskEventStore } from "../stores/task-event-store.ts";
-import type { TaskScopeStore } from "../stores/task-scope-store.ts";
-import { projectTaskExecution, TaskExecutionBoundExceededError, type TaskExecutionPlan } from "../task/task-execution.ts";
-import type { TaskGraph, TaskNode, TaskStatus } from "../task/task-service.ts";
+} from "./blueprint-definition.ts";
 import { compilePlaybookDefinition, type PlaybookExternalLink } from "./playbook-definition.ts";
 
 const RUN_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;

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

@@ -1,8 +1,8 @@
 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";
+import type { Project, RegisterProjectInput } from "../project-registry/project-registry.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
 
 export function uniqueAliases(values: readonly string[], name: string): string[] {
 	const seen = new Set([name.trim().toLowerCase()]);

package/src/{ports → project-registry}/project-registry-store.ts

@@ -1,4 +1,4 @@
-import type { Project, RegisterProjectInput } from "../domain/project-registry.ts";
+import type { Project, RegisterProjectInput } from "../project-registry/project-registry.ts";
 
 /**
  * Kind-neutral project identity, shared by Task scope and every non-Task artifact scope

package/src/{stores → project-registry}/sqlite-project-registry-store.ts

@@ -2,9 +2,9 @@ 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";
+import { uniqueAliases } from "../project-registry/in-memory-project-registry-store.ts";
+import type { Project, RegisterProjectInput } from "../project-registry/project-registry.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
 
 interface ProjectRow {
 	id: string;

package/src/rules/rules-service.ts

@@ -10,26 +10,29 @@ import { requireLocallyOwnedContent } from "../artifact/artifact.ts";
 import type { ArtifactEventContext } from "../artifact/artifact-event.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 {
+	addArtifactScopeGroup,
+	addArtifactScopeProject,
 	assertLabelsBounds,
 	assertTitleBounds,
 	assignArtifactProject,
 	type ListFilter,
 	listScoped,
+	removeArtifactScopeGroup,
+	removeArtifactScopeProject,
+	replaceArtifactScopeGroups,
+	replaceArtifactScopeProjects,
 	requireContentUpdateFields,
 	requireKind,
 	runTransition,
+	setArtifactScopeNone,
 	type TransitionTable,
 	type UpdateContentInput,
 } from "../domain-service-shared.ts";
-import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
+import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
+import { normalizeProjectRoot } from "../task-scope/task-scope.ts";
 
 export interface CreateRuleInput {
 	title: string;
@@ -156,11 +159,7 @@ export function createRule(
 		context,
 	);
 	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");
+		replaceArtifactScopeProjects(scopes, registry!, rule.id, input.projectReferences);
 	} else {
 		scopes.assign(rule.id, projectRoot, projectRoot === undefined ? "unscoped" : "explicit");
 	}
@@ -195,7 +194,13 @@ export function ruleScope(artifacts: ArtifactStore, scopes: ArtifactScopeStore,
 
 export function setRuleGlobal(artifacts: ArtifactStore, scopes: ArtifactScopeStore, id: string): ArtifactScope {
 	requireKind(artifacts, id, "rule");
-	return scopes.setGlobal(id, "explicit");
+	return scopes.setAll(id, "explicit");
+}
+
+/** Fully hides this Rule -- never applicable, never injected, regardless of project. */
+export function setRuleNone(artifacts: ArtifactStore, scopes: ArtifactScopeStore, id: string): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	return setArtifactScopeNone(scopes, id);
 }
 
 export function replaceRuleProjects(
@@ -206,12 +211,7 @@ export function replaceRuleProjects(
 	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");
+	return replaceArtifactScopeProjects(scopes, registry, id, projectReferences);
 }
 
 export function addRuleProject(
@@ -222,8 +222,7 @@ export function addRuleProject(
 	projectReference: string,
 ): ArtifactScope {
 	requireKind(artifacts, id, "rule");
-	const project = resolveProjectReference(registry, projectReference);
-	return scopes.addProject(id, project.id, "explicit");
+	return addArtifactScopeProject(scopes, registry, id, projectReference);
 }
 
 export function removeRuleProject(
@@ -234,8 +233,41 @@ export function removeRuleProject(
 	projectReference: string,
 ): ArtifactScope {
 	requireKind(artifacts, id, "rule");
-	const project = resolveProjectReference(registry, projectReference);
-	return scopes.removeProject(id, project.id);
+	return removeArtifactScopeProject(scopes, registry, id, projectReference);
+}
+
+/** Scope-group ('nested scope') siblings of replaceRuleProjects/addRuleProject/removeRuleProject. */
+export function replaceRuleGroups(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	scopeGroups: ScopeGroupStore,
+	id: string,
+	groupReferences: readonly string[],
+): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	return replaceArtifactScopeGroups(scopes, scopeGroups, id, groupReferences);
+}
+
+export function addRuleGroup(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	scopeGroups: ScopeGroupStore,
+	id: string,
+	groupReference: string,
+): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	return addArtifactScopeGroup(scopes, scopeGroups, id, groupReference);
+}
+
+export function removeRuleGroup(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	scopeGroups: ScopeGroupStore,
+	id: string,
+	groupReference: string,
+): ArtifactScope {
+	requireKind(artifacts, id, "rule");
+	return removeArtifactScopeGroup(scopes, scopeGroups, id, groupReference);
 }
 
 /** 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. */

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

@@ -0,0 +1,17 @@
+import type { ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
+import { ScopeGroupInUseError } from "./scope-group.ts";
+import type { ScopeGroupStore } from "./scope-group-store.ts";
+
+/**
+ * The one real cross-store check a plain ScopeGroupStore.delete() cannot make on its own: whether
+ * any Doc/Rule/Playbook's own explicit scope still references this group. ScopeGroupStore.delete()
+ * itself only checks the self-consistency case (another group's own membership) -- deliberately,
+ * so the store's own port stays kind-agnostic and never depends on ArtifactScopeStore. This
+ * orchestration function is the one real caller that holds both.
+ */
+export function deleteScopeGroup(scopeGroups: ScopeGroupStore, artifactScopes: ArtifactScopeStore, groupId: string): void {
+	if (artifactScopes.referencesGroup(groupId)) {
+		throw new ScopeGroupInUseError(`scope group "${groupId}" is still referenced by at least one artifact's explicit scope`);
+	}
+	scopeGroups.delete(groupId);
+}