@danypops/papyrus 0.60.0 → 0.60.2

package/src/handlers/binders.ts

@@ -0,0 +1,231 @@
+import type { VehicleRegistry } from "@danypops/vehicle-server";
+import type { ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
+import type { ArtifactStore } from "../artifact/artifact-store.ts";
+import type { ArtifactTrashStore } from "../artifact/artifact-trash-store.ts";
+import { binderTree } from "../binder/binder-service.ts";
+import { bindersOperations } from "../modules/binders.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
+import { normalizeProjectRoot } from "../project-registry/scope-source.ts";
+import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
+import { booleanProp, createOperationDefiner, numberProp, resolveArtifactIdWidened, stringProp, validationError } from "./shared.ts";
+
+const OWNER = "binders";
+
+function resolveBinderId(
+	artifacts: ArtifactStore,
+	scopes: ArtifactScopeStore,
+	projectRoot: string | undefined,
+	id: unknown,
+	name: unknown,
+): string {
+	if (typeof id === "string" && id.length > 0) return id;
+	if (typeof name !== "string" || name.trim().length === 0) throw validationError("id or name is required");
+	const alias = artifacts.getByAlias(name.trim());
+	if (alias?.kind === "binder" && (projectRoot === undefined || scopes.appliesToProjectRoot(alias.id, normalizeProjectRoot(projectRoot)))) {
+		return alias.id;
+	}
+	const tree = binderTree(artifacts, scopes, { projectRoot });
+	const pathNeedle = name.trim().startsWith("/") ? name.trim() : `/${name.trim()}`;
+	const pathMatches = tree.nodes.filter((node) => node.path.toLowerCase() === pathNeedle.toLowerCase());
+	if (pathMatches.length === 1) return pathMatches[0]!.binder.id;
+	const titleMatches = tree.nodes.filter((node) => node.binder.title.trim().toLowerCase() === name.trim().toLowerCase());
+	if (titleMatches.length === 1) return titleMatches[0]!.binder.id;
+	if (titleMatches.length > 1 || pathMatches.length > 1) {
+		const matches = pathMatches.length > 0 ? pathMatches : titleMatches;
+		throw validationError(`binder name "${name}" is ambiguous: ${matches.map((node) => node.path).join(", ")} -- use a path or id`);
+	}
+	throw validationError(`no binder named "${name}" found in this project context`);
+}
+
+function resolveAnyArtifactId(artifacts: ArtifactStore, id: unknown, name: unknown): string {
+	if (typeof id === "string" && id.length > 0) return id;
+	if (typeof name !== "string" || name.trim().length === 0) throw validationError("artifact_id or artifact_name is required");
+	return resolveArtifactIdWidened(artifacts, name, () => artifacts.query({ text: name }));
+}
+
+export function registerBindersVehicleOperations(
+	registry: VehicleRegistry,
+	artifacts: ArtifactStore & ArtifactTrashStore,
+	scopes: ArtifactScopeStore,
+	projectRegistry: ProjectRegistryStore,
+	scopeGroups: ScopeGroupStore,
+): void {
+	const operations = new Map(
+		bindersOperations(artifacts, scopes, projectRegistry, scopeGroups).map((operation) => [operation.name, operation]),
+	);
+	const call = (name: string, input: Record<string, unknown>): unknown => operations.get(name)!.execute(input);
+	const define = createOperationDefiner(registry, OWNER, "binders", ["binders:read", "binders:write"], call);
+	const arrayProp = { type: "array" } as unknown as { type: string };
+	const withBinderId = (input: Record<string, unknown>, idKey = "id", nameKey = "name") => ({
+		...input,
+		[idKey]: resolveBinderId(artifacts, scopes, input.project_root as string | undefined, input[idKey], input[nameKey]),
+	});
+
+	define(
+		"create",
+		"Creates a filesystem-style Binder. Binders organize artifacts without changing Task containment or Playbook execution. Direct labels on a Binder are inherited additively by descendants at read time. Prefer parent_name (a title, alias, or /path) over parent_id.",
+		"local-write",
+		{ title: stringProp, labels: arrayProp, parent_id: stringProp, parent_name: stringProp, project_root: stringProp, projects: arrayProp },
+		["title"],
+		(input) => ({
+			...input,
+			...(input.parent_id || input.parent_name
+				? { parent_id: resolveBinderId(artifacts, scopes, input.project_root as string | undefined, input.parent_id, input.parent_name) }
+				: {}),
+		}),
+	);
+	define(
+		"list",
+		"Lists Binders. project_root alone is exact-membership audit scope; project_root plus applicable:true includes global Binders and Binders applicable to the project. Returns lean summaries unless full:true.",
+		"read",
+		{ text: stringProp, limit: numberProp, project_root: stringProp, applicable: booleanProp, full: booleanProp },
+		[],
+		(input) => input,
+	);
+	define(
+		"tree",
+		"Returns the project-context Binder tree plus placements and direct/inherited/effective labels for the bounded artifact_ids supplied. Label inheritance is computed, not copied into artifact labels.",
+		"read",
+		{ project_root: stringProp, artifact_ids: arrayProp },
+		[],
+		(input) => input,
+	);
+	define(
+		"show",
+		"Shows one Binder node by id, alias, title, or /path, including its path and inherited/effective labels.",
+		"read",
+		{ id: stringProp, name: stringProp, project_root: stringProp },
+		[],
+		(input) => withBinderId(input),
+	);
+	define(
+		"update",
+		"Renames a Binder and/or replaces its direct labels. Inherited labels on descendants update immediately because they are computed dynamically.",
+		"local-write",
+		{ id: stringProp, name: stringProp, title: stringProp, labels: arrayProp, project_root: stringProp },
+		[],
+		(input) => withBinderId(input),
+	);
+	define(
+		"move",
+		"Moves a Binder under parent_id/parent_name, or to the project-context root when neither is supplied. Rejects cycles and duplicate sibling names.",
+		"local-write",
+		{ id: stringProp, name: stringProp, parent_id: stringProp, parent_name: stringProp, project_root: stringProp },
+		[],
+		(input) => {
+			const resolved = withBinderId(input);
+			return {
+				...resolved,
+				...(input.parent_id || input.parent_name
+					? { parent_id: resolveBinderId(artifacts, scopes, input.project_root as string | undefined, input.parent_id, input.parent_name) }
+					: {}),
+			};
+		},
+	);
+	define(
+		"file",
+		"Files one non-Binder artifact in a Binder for this project context, replacing its previous visible placement. Prefer binder_name/artifact_name over ids when unambiguous.",
+		"local-write",
+		{
+			binder_id: stringProp,
+			binder_name: stringProp,
+			artifact_id: stringProp,
+			artifact_name: stringProp,
+			project_root: stringProp,
+		},
+		[],
+		(input) => ({
+			...input,
+			binder_id: resolveBinderId(artifacts, scopes, input.project_root as string | undefined, input.binder_id, input.binder_name),
+			artifact_id: resolveAnyArtifactId(artifacts, input.artifact_id, input.artifact_name),
+		}),
+	);
+	define(
+		"unfile",
+		"Moves one artifact to this project context's Binder root. This changes organization only, never Task containment or dependencies.",
+		"local-write",
+		{ artifact_id: stringProp, artifact_name: stringProp, project_root: stringProp },
+		[],
+		(input) => ({ ...input, artifact_id: resolveAnyArtifactId(artifacts, input.artifact_id, input.artifact_name) }),
+	);
+	define(
+		"remove",
+		"Trashes an empty Binder. A non-empty Binder is rejected until its contents are moved or unfiled.",
+		"local-write",
+		{ id: stringProp, name: stringProp, project_root: stringProp, reason: stringProp },
+		[],
+		(input) => withBinderId(input),
+	);
+	define(
+		"scope",
+		"Shows a Binder's project/scope-group scope.",
+		"read",
+		{ id: stringProp, name: stringProp, project_root: stringProp },
+		[],
+		(input) => withBinderId(input),
+	);
+	define(
+		"set_global",
+		"Makes a Binder apply in every project.",
+		"local-write",
+		{ id: stringProp, name: stringProp, project_root: stringProp },
+		[],
+		(input) => withBinderId(input),
+	);
+	define(
+		"set_none",
+		"Hides a Binder from every project context.",
+		"local-write",
+		{ id: stringProp, name: stringProp, project_root: stringProp },
+		[],
+		(input) => withBinderId(input),
+	);
+	define(
+		"add_project",
+		"Adds one registered project to a Binder's explicit scope.",
+		"local-write",
+		{ id: stringProp, name: stringProp, project: stringProp, project_root: stringProp },
+		["project"],
+		(input) => withBinderId(input),
+	);
+	define(
+		"remove_project",
+		"Removes one project from a Binder's explicit scope; removing the final member is rejected.",
+		"local-write",
+		{ id: stringProp, name: stringProp, project: stringProp, project_root: stringProp },
+		["project"],
+		(input) => withBinderId(input),
+	);
+	define(
+		"replace_projects",
+		"Replaces a Binder's project membership with a bounded non-empty list.",
+		"local-write",
+		{ id: stringProp, name: stringProp, projects: arrayProp, project_root: stringProp },
+		["projects"],
+		(input) => withBinderId(input),
+	);
+	define(
+		"add_group",
+		"Adds one nested scope group to a Binder's explicit scope.",
+		"local-write",
+		{ id: stringProp, name: stringProp, group: stringProp, project_root: stringProp },
+		["group"],
+		(input) => withBinderId(input),
+	);
+	define(
+		"remove_group",
+		"Removes one scope group from a Binder's explicit scope; removing the final member is rejected.",
+		"local-write",
+		{ id: stringProp, name: stringProp, group: stringProp, project_root: stringProp },
+		["group"],
+		(input) => withBinderId(input),
+	);
+	define(
+		"replace_groups",
+		"Replaces a Binder's scope-group membership with a bounded non-empty list.",
+		"local-write",
+		{ id: stringProp, name: stringProp, groups: arrayProp, project_root: stringProp },
+		["groups"],
+		(input) => withBinderId(input),
+	);
+}

package/src/handlers/registry.ts

@@ -21,6 +21,7 @@ import type { TaskScopeStore } from "../task/scope/task-scope-store.ts";
 import type { Tasks } from "../task/task-service.ts";
 import { registerArtifactTrashOperations } from "./artifact-trash.ts";
 import { registerBatchVehicleOperation } from "./batch.ts";
+import { registerBindersVehicleOperations } from "./binders.ts";
 import { registerDiscussVehicleOperations } from "./discuss.ts";
 import { registerDocsVehicleOperations } from "./docs.ts";
 import { registerNotesVehicleOperations } from "./notes.ts";
@@ -56,6 +57,7 @@ export function createPapyrusVehicleRegistry(deps: PapyrusVehicleDeps): VehicleR
 	// session_id, a correlation id, not a secret -- see session-identity-service.ts).
 	registry.setExposeHandlerFailureDetails(true);
 	registerNotesVehicleOperations(registry, deps.notes, deps.artifacts);
+	registerBindersVehicleOperations(registry, deps.artifacts, deps.scopes, deps.projectRegistry, deps.scopeGroups);
 	registerRulesVehicleOperations(registry, deps.artifacts, deps.scopes, deps.projectRegistry, deps.scopeGroups);
 	registerDocsVehicleOperations(registry, deps.artifacts, deps.scopes, deps.authority, deps.projectRegistry, deps.scopeGroups);
 	registerPlaybooksVehicleOperations(registry, {

package/src/handlers/tasks.ts

@@ -19,7 +19,12 @@
  *
  * remove/remove_subtree/restore are not duplicated here -- see ./artifact-trash-vehicle.ts.
  */
-import { VehicleError, type VehicleLimits, type VehicleOperationContext } from "@danypops/vehicle-core";
+import {
+	VEHICLE_SCHEMA_PRESENTATION_EXTENSION,
+	VehicleError,
+	type VehicleLimits,
+	type VehicleOperationContext,
+} from "@danypops/vehicle-core";
 import type { VehicleRegistry } from "@danypops/vehicle-server";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
 import { GATE_TIMEOUT_MAX_MS, TASK_CREATE_IDEMPOTENCY_KEY_MAX_LENGTH, TASK_MUTATION_IDEMPOTENCY_KEY_MAX_LENGTH } from "../constants.ts";
@@ -83,6 +88,7 @@ const GATE_OPERATION_LIMITS: VehicleLimits = {
 const objectProp = { type: "object" } as const;
 const arrayProp = { type: "array" } as const;
 const _boolProp = { type: "boolean" } as const;
+const streamingStringProp = { ...stringProp, [VEHICLE_SCHEMA_PRESENTATION_EXTENSION]: "stream" } as const;
 const mutationIdempotencyProp = {
 	type: "string",
 	minLength: 1,
@@ -368,7 +374,7 @@ export function registerTasksVehicleOperations(registry: VehicleRegistry, deps:
 		"local-write",
 		{
 			title: stringProp,
-			body: stringProp,
+			body: streamingStringProp,
 			status: stringProp,
 			labels: arrayProp,
 			extra: objectProp,
@@ -418,7 +424,7 @@ export function registerTasksVehicleOperations(registry: VehicleRegistry, deps:
 			id: stringProp,
 			name: stringProp,
 			title: stringProp,
-			body: stringProp,
+			body: streamingStringProp,
 			labels: arrayProp,
 			status: stringProp,
 			reason: stringProp,

package/src/index.ts

@@ -8,6 +8,14 @@
 export type { Artifact, ArtifactEdge } from "./artifact/artifact.ts";
 export { projectArtifactRelationships } from "./artifact/artifact-relationship-view.ts";
 export type { ArtifactStore } from "./artifact/artifact-store.ts";
+export {
+	BINDER_FILED_IN_RELATION,
+	BINDER_KIND,
+	BINDER_ORGANIZES_RELATION,
+	type BinderArtifactPlacement,
+	type BinderNode,
+	type BinderTree,
+} from "./binder/binder.ts";
 export {
 	connectPapyrusClient,
 	type PapyrusClient,

package/src/modules/binders.ts

@@ -0,0 +1,171 @@
+import { summarizeArtifact } from "../artifact/artifact.ts";
+import type { ArtifactScopeStore } from "../artifact/artifact-scope-store.ts";
+import type { ArtifactStore } from "../artifact/artifact-store.ts";
+import type { ArtifactTrashStore } from "../artifact/artifact-trash-store.ts";
+import {
+	addBinderGroup,
+	addBinderProject,
+	binderScope,
+	binderTree,
+	createBinder,
+	fileArtifact,
+	listBinders,
+	moveBinder,
+	removeBinder,
+	removeBinderGroup,
+	removeBinderProject,
+	replaceBinderGroups,
+	replaceBinderProjects,
+	setBinderGlobal,
+	setBinderNone,
+	unfileArtifact,
+	updateBinder,
+} from "../binder/binder-service.ts";
+import type { OperationDefinition } from "../module-registry.ts";
+import type { ProjectRegistryStore } from "../project-registry/project-registry-store.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 = "binders";
+
+const eventContext = (input: OperationInput) => ({
+	actor: optionalString(input, "actor"),
+	source: optionalString(input, "source"),
+	sessionId: optionalString(input, "session_id") ?? optionalString(input, "sessionId"),
+});
+
+const listFilter = (input: OperationInput) => {
+	const projectRoot = optionalString(input, "project_root");
+	const applicable = optionalBoolean(input, "applicable") === true;
+	if (applicable && projectRoot === undefined) throw new Error("applicable requires project_root");
+	return {
+		text: optionalString(input, "text"),
+		limit: optionalNumber(input, "limit"),
+		...(applicable ? { applicableToProjectRoot: projectRoot } : { projectRoot }),
+	};
+};
+
+export const BINDERS_OPERATION_NAMES = [
+	"binders.create",
+	"binders.list",
+	"binders.tree",
+	"binders.show",
+	"binders.update",
+	"binders.move",
+	"binders.file",
+	"binders.unfile",
+	"binders.remove",
+	"binders.scope",
+	"binders.set_global",
+	"binders.set_none",
+	"binders.add_project",
+	"binders.remove_project",
+	"binders.replace_projects",
+	"binders.add_group",
+	"binders.remove_group",
+	"binders.replace_groups",
+] as const;
+
+export function bindersOperations(
+	artifacts: ArtifactStore & ArtifactTrashStore,
+	scopes: ArtifactScopeStore,
+	registry: ProjectRegistryStore,
+	scopeGroups: ScopeGroupStore,
+): OperationDefinition[] {
+	const define = <Input, Output>(name: string, execute: (input: Input) => Output): OperationDefinition<Input, Output> => ({
+		name,
+		moduleId: MODULE_ID,
+		execute,
+	});
+	return [
+		define("binders.create", (input: OperationInput) =>
+			createBinder(
+				artifacts,
+				scopes,
+				{
+					title: string(input, "title"),
+					labels: input.labels as string[] | undefined,
+					parentId: optionalString(input, "parent_id"),
+					projectRoot: optionalString(input, "project_root"),
+					projectReferences: input.projects as string[] | undefined,
+				},
+				eventContext(input),
+				registry,
+			),
+		),
+		define("binders.list", (input: OperationInput) => {
+			const binders = listBinders(artifacts, scopes, listFilter(input));
+			return optionalBoolean(input, "full") === true ? binders : binders.map(summarizeArtifact);
+		}),
+		define("binders.tree", (input: OperationInput) =>
+			binderTree(artifacts, scopes, {
+				projectRoot: optionalString(input, "project_root"),
+				artifactIds: input.artifact_ids as string[] | undefined,
+			}),
+		),
+		define("binders.show", (input: OperationInput) => {
+			const id = string(input, "id");
+			const tree = binderTree(artifacts, scopes, { projectRoot: optionalString(input, "project_root") });
+			const node = tree.nodes.find((candidate) => candidate.binder.id === id);
+			if (!node) throw new Error(`binder artifact "${id}" not found in this project context`);
+			return node;
+		}),
+		define("binders.update", (input: OperationInput) =>
+			updateBinder(
+				artifacts,
+				scopes,
+				string(input, "id"),
+				{ title: optionalString(input, "title"), labels: input.labels as string[] | undefined },
+				optionalString(input, "project_root"),
+				eventContext(input),
+			),
+		),
+		define("binders.move", (input: OperationInput) =>
+			moveBinder(
+				artifacts,
+				scopes,
+				string(input, "id"),
+				optionalString(input, "parent_id"),
+				optionalString(input, "project_root"),
+				eventContext(input),
+			),
+		),
+		define("binders.file", (input: OperationInput) =>
+			fileArtifact(
+				artifacts,
+				scopes,
+				string(input, "artifact_id"),
+				string(input, "binder_id"),
+				optionalString(input, "project_root"),
+				eventContext(input),
+			),
+		),
+		define("binders.unfile", (input: OperationInput) =>
+			unfileArtifact(artifacts, scopes, string(input, "artifact_id"), optionalString(input, "project_root"), eventContext(input)),
+		),
+		define("binders.remove", (input: OperationInput) =>
+			removeBinder(artifacts, string(input, "id"), eventContext(input), optionalString(input, "reason")),
+		),
+		define("binders.scope", (input: OperationInput) => binderScope(artifacts, scopes, string(input, "id"))),
+		define("binders.set_global", (input: OperationInput) => setBinderGlobal(artifacts, scopes, string(input, "id"))),
+		define("binders.set_none", (input: OperationInput) => setBinderNone(artifacts, scopes, string(input, "id"))),
+		define("binders.add_project", (input: OperationInput) =>
+			addBinderProject(artifacts, scopes, registry, string(input, "id"), string(input, "project")),
+		),
+		define("binders.remove_project", (input: OperationInput) =>
+			removeBinderProject(artifacts, scopes, registry, string(input, "id"), string(input, "project")),
+		),
+		define("binders.replace_projects", (input: OperationInput) =>
+			replaceBinderProjects(artifacts, scopes, registry, string(input, "id"), (input.projects as string[] | undefined) ?? []),
+		),
+		define("binders.add_group", (input: OperationInput) =>
+			addBinderGroup(artifacts, scopes, scopeGroups, string(input, "id"), string(input, "group")),
+		),
+		define("binders.remove_group", (input: OperationInput) =>
+			removeBinderGroup(artifacts, scopes, scopeGroups, string(input, "id"), string(input, "group")),
+		),
+		define("binders.replace_groups", (input: OperationInput) =>
+			replaceBinderGroups(artifacts, scopes, scopeGroups, string(input, "id"), (input.groups as string[] | undefined) ?? []),
+		),
+	];
+}

package/src/project-registry/scope-source.ts

@@ -1,4 +1,4 @@
-import { basename, isAbsolute, normalize } from "node:path";
+import { isAbsolute, normalize } from "node:path";
 import { TASK_PROJECT_ROOT_MAX_LENGTH } from "../constants.ts";
 
 /** How a project root got attached to a scoped artifact -- shared across Tasks/Docs/Rules/Playbooks, same category as Project in project-registry.ts. */

package/src/service.ts

@@ -12,6 +12,7 @@ import type { ArtifactTrashStore } from "./artifact/artifact-trash-store.ts";
 import { SQLiteArtifactScopeStore } from "./artifact/sqlite-artifact-scope-store.ts";
 import { SQLiteArtifactStore } from "./artifact/sqlite-artifact-store.ts";
 import { type AuthorityClaim, AuthorityRegistry, AuthorizedArtifactWriter } from "./authority-registry.ts";
+import { BINDER_FILED_IN_RELATION, BINDER_KIND, BINDER_ORGANIZES_RELATION } from "./binder/binder.ts";
 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";
@@ -25,6 +26,7 @@ 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 { BINDERS_OPERATION_NAMES, bindersOperations } from "./modules/binders.ts";
 import { DISCUSS_OPERATION_NAMES, discussOperations } from "./modules/discuss.ts";
 import { DOCS_OPERATION_NAMES, docsOperations } from "./modules/docs.ts";
 import { GRAPH_PROJECTION_OPERATION_NAMES, graphProjectionOperations } from "./modules/graph-projection.ts";
@@ -99,6 +101,7 @@ const COMPOSITION_ROOT_OPERATION_NAMES = [
 export const EXPECTED_OPERATION_NAMES = [
 	...COMPOSITION_ROOT_OPERATION_NAMES,
 	...TASKS_OPERATION_NAMES,
+	...BINDERS_OPERATION_NAMES,
 	...DOCS_OPERATION_NAMES,
 	...NOTES_OPERATION_NAMES,
 	...RULES_OPERATION_NAMES,
@@ -163,6 +166,13 @@ const tasksAuthorityClaim: AuthorityClaim = {
 	denyMessage: () => "task lifecycle changes require a tasks.* operation so history and review invariants are preserved",
 };
 
+const bindersAuthorityClaim: AuthorityClaim = {
+	owner: "binders",
+	matchesArtifact: (kind) => kind === BINDER_KIND,
+	matchesRelation: (relation) => relation === BINDER_ORGANIZES_RELATION || relation === BINDER_FILED_IN_RELATION,
+	denyMessage: () => "Binder creation, hierarchy, and filing require a binders.* operation so path and cycle invariants are preserved",
+};
+
 /**
  * The same status-bypass protection Tasks and Notes already have, extended to every other kind
  * with its own validated transition set (Doc's draft/active/archived, Rule/Playbook's
@@ -183,6 +193,7 @@ export function createAuthorityRegistry(): AuthorityRegistry {
 	authority.claimAll([
 		notesAuthorityClaim,
 		tasksAuthorityClaim,
+		bindersAuthorityClaim,
 		lifecycleAuthorityClaim("docs", "doc"),
 		lifecycleAuthorityClaim("rules", "rule"),
 		lifecycleAuthorityClaim("playbooks", "playbook"),
@@ -320,10 +331,20 @@ function handlers(
 				depth: optionalNumber(input, "depth"),
 				maxNodes: optionalNumber(input, "max_nodes") ?? optionalNumber(input, "maxNodes"),
 			}),
-		"artifact.remove": (input) =>
-			artifacts.trash(string(input, "id"), { reason: optionalString(input, "reason"), context: eventContext(input) }),
-		"artifact.remove_subtree": (input) =>
-			removeArtifactSubtree(artifacts, string(input, "id"), { reason: optionalString(input, "reason"), context: eventContext(input) }),
+		"artifact.remove": (input) => {
+			const id = string(input, "id");
+			if (artifacts.get(id)?.kind === BINDER_KIND) {
+				throw new Error("Binder removal requires binders.remove so a non-empty directory cannot be orphaned");
+			}
+			return artifacts.trash(id, { reason: optionalString(input, "reason"), context: eventContext(input) });
+		},
+		"artifact.remove_subtree": (input) => {
+			const id = string(input, "id");
+			if (artifacts.get(id)?.kind === BINDER_KIND) {
+				throw new Error("Binder removal requires binders.remove so a non-empty directory cannot be orphaned");
+			}
+			return removeArtifactSubtree(artifacts, id, { reason: optionalString(input, "reason"), context: eventContext(input) });
+		},
 		"artifact.restore": (input) => artifacts.restore(string(input, "id"), eventContext(input)),
 		"artifact.trash_status": (input) => artifacts.trashStatus(string(input, "id")),
 		"artifact.trash_list": () => artifacts.listTrash(),
@@ -428,6 +449,24 @@ function handlers(
 		"tasks.reap_stale_leases": forwardToModule("tasks.reap_stale_leases"),
 		"tasks.event_feed": forwardToModule("tasks.event_feed"),
 		"tasks.reap_stale_focus": forwardToModule("tasks.reap_stale_focus"),
+		"binders.create": forwardToModule("binders.create"),
+		"binders.list": forwardToModule("binders.list"),
+		"binders.tree": forwardToModule("binders.tree"),
+		"binders.show": forwardToModule("binders.show"),
+		"binders.update": forwardToModule("binders.update"),
+		"binders.move": forwardToModule("binders.move"),
+		"binders.file": forwardToModule("binders.file"),
+		"binders.unfile": forwardToModule("binders.unfile"),
+		"binders.remove": forwardToModule("binders.remove"),
+		"binders.scope": forwardToModule("binders.scope"),
+		"binders.set_global": forwardToModule("binders.set_global"),
+		"binders.set_none": forwardToModule("binders.set_none"),
+		"binders.add_project": forwardToModule("binders.add_project"),
+		"binders.remove_project": forwardToModule("binders.remove_project"),
+		"binders.replace_projects": forwardToModule("binders.replace_projects"),
+		"binders.add_group": forwardToModule("binders.add_group"),
+		"binders.remove_group": forwardToModule("binders.remove_group"),
+		"binders.replace_groups": forwardToModule("binders.replace_groups"),
 		"docs.create": forwardToModule("docs.create"),
 		"docs.list": forwardToModule("docs.list"),
 		"docs.show": forwardToModule("docs.show"),
@@ -563,6 +602,7 @@ export function createPapyrusService(path: string): PapyrusService {
 	moduleRegistry.registerAll(sessionIdentityOperations(sessionIdentity));
 	moduleRegistry.registerAll(discussOperations(discussions));
 	moduleRegistry.registerAll(tasksOperations(tasks, artifacts, sessionIdentity));
+	moduleRegistry.registerAll(bindersOperations(artifacts, artifactScopes, projectRegistry, scopeGroups));
 	moduleRegistry.registerAll(docsOperations(artifacts, artifactScopes, authority, projectRegistry, scopeGroups));
 	moduleRegistry.registerAll(rulesOperations(artifacts, artifactScopes, projectRegistry, scopeGroups));
 	moduleRegistry.registerAll(