@danypops/papyrus 0.57.1 → 0.58.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.57.1",
+  "version": "0.58.1",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "main": "./src/index.ts",

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

@@ -1,16 +1,12 @@
+import type { ScopeAssignmentSource } from "../project-registry/scope-source.ts";
 import type { ScopeMemberRef } from "../scope-group/scope-group.ts";
-import type { TaskScopeSource } from "../task-scope/task-scope.ts";
 
 /**
- * Project scoping for Docs/Rules/Playbooks: an artifact is explicitly "none" (hidden -- never
- * applicable, never context-injected, regardless of project), explicitly "all" (applies
- * everywhere), or bound to a bounded, non-empty set of explicit members -- never inferred from
- * an accidentally empty join table, which is why `mode` is its own explicit field rather than
- * "members.length === 0 means none/all". A member is either a registered project (from the
- * shared ProjectRegistryStore) or a scope group (from ScopeGroupStore, itself a possibly-nested
- * collection of projects/groups) -- "explicit scope can include nested scopes". Membership is by
- * id, never by root/name, so a registered project's root (or a group's name) can move without a
- * best-effort string rewrite across every artifact that references it.
+ * Project scoping for Docs/Rules/Playbooks: "none" hides an artifact from context injection
+ * entirely, "all" applies it everywhere, "explicit" binds it to a non-empty member set (a
+ * project or a possibly-nested scope group). `mode` is its own field rather than inferred from
+ * an empty member list, and membership is by id rather than root/name, so a project or group can
+ * be renamed/moved without rewriting every artifact that references it.
  */
 export type ArtifactScopeMode = "none" | "all" | "explicit";
 
@@ -19,13 +15,13 @@ export interface ArtifactScope {
 	mode: ArtifactScopeMode;
 	/** Direct membership only (not expanded through nested groups) -- always empty when mode is "none"/"all", always non-empty when mode is "explicit". */
 	members: ScopeMemberRef[];
-	source: TaskScopeSource;
+	source: ScopeAssignmentSource;
 }
 
 export interface LegacyArtifactScope {
 	artifactId: string;
 	projectRoot?: string;
-	source: TaskScopeSource;
+	source: ScopeAssignmentSource;
 }
 
 export interface ArtifactScopeStore {
@@ -34,15 +30,15 @@ export interface ArtifactScopeStore {
 	/** Single-root compatibility view over scope(): an "all"/"none" or unscoped artifact omits projectRoot; an "explicit" mode artifact with exactly one project-type membership (and no group members) resolves it back to that project's current root; anything else (zero, more than one, or any group membership) omits projectRoot, since this shape cannot represent it. */
 	get(artifactId: string): LegacyArtifactScope | undefined;
 	/** Single-root compatibility shim: registers/resolves projectRoot and replaces the artifact's scope with exactly that one project membership, or setAll() when projectRoot is undefined. Every existing caller (rules/docs/playbooks assign_project) keeps working unchanged. */
-	assign(artifactId: string, projectRoot: string | undefined, source: TaskScopeSource): LegacyArtifactScope;
+	assign(artifactId: string, projectRoot: string | undefined, source: ScopeAssignmentSource): LegacyArtifactScope;
 	/** Sets an artifact to explicitly "all" (applies everywhere), clearing any membership. */
-	setAll(artifactId: string, source: TaskScopeSource): ArtifactScope;
+	setAll(artifactId: string, source: ScopeAssignmentSource): ArtifactScope;
 	/** Sets an artifact to explicitly "none" (fully hidden -- never applicable, never context-injected, regardless of project), clearing any membership. */
-	setNone(artifactId: string, source: TaskScopeSource): ArtifactScope;
+	setNone(artifactId: string, source: ScopeAssignmentSource): ArtifactScope;
 	/** Replaces an artifact's entire explicit membership set with exactly these (project and/or group) members -- must be non-empty; use setAll/setNone to clear scoping entirely. */
-	replaceMembers(artifactId: string, members: readonly ScopeMemberRef[], source: TaskScopeSource): ArtifactScope;
+	replaceMembers(artifactId: string, members: readonly ScopeMemberRef[], source: ScopeAssignmentSource): ArtifactScope;
 	/** Adds one member to an artifact's explicit membership (idempotent), switching mode to "explicit" if it was "all"/"none". Enforces the bounded maximum membership count. */
-	addMember(artifactId: string, member: ScopeMemberRef, source: TaskScopeSource): ArtifactScope;
+	addMember(artifactId: string, member: ScopeMemberRef, source: ScopeAssignmentSource): ArtifactScope;
 	/** Removes one member from an artifact's explicit membership (idempotent). Rejects removing the last membership while mode is "explicit": a caller must explicitly call setAll/setNone instead of accidentally broadening/narrowing scope by emptying the set. */
 	removeMember(artifactId: string, member: ScopeMemberRef): ArtifactScope;
 	/** Bounded id listing for one project root's EXACT direct membership (or the "all" bucket when projectRoot is undefined) -- an unregistered root always yields an empty list. Deliberately does not expand nested groups (audit semantics, matching this method's own pre-existing "exact membership" contract) -- use appliesToProjectRoot for the applicable/injection query instead. */

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

@@ -1,16 +1,16 @@
 import { ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT } from "../constants.ts";
 import { InMemoryProjectRegistryStore } from "../project-registry/in-memory-project-registry-store.ts";
 import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
+import type { ScopeAssignmentSource } from "../project-registry/scope-source.ts";
 import { InMemoryScopeGroupStore } from "../scope-group/in-memory-scope-group-store.ts";
 import { type ScopeMemberRef, sameScopeMember } from "../scope-group/scope-group.ts";
 import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
-import type { TaskScopeSource } from "../task-scope/task-scope.ts";
 import type { ArtifactScope, ArtifactScopeMode, ArtifactScopeStore, LegacyArtifactScope } from "./artifact-scope-store.ts";
 
 interface Row {
 	mode: ArtifactScopeMode;
 	members: ScopeMemberRef[];
-	source: TaskScopeSource;
+	source: ScopeAssignmentSource;
 }
 
 export class InMemoryArtifactScopeStore implements ArtifactScopeStore {
@@ -18,9 +18,7 @@ export class InMemoryArtifactScopeStore implements ArtifactScopeStore {
 	private readonly registry: InMemoryProjectRegistryStore;
 	private readonly scopeGroups: ScopeGroupStore;
 
-	// Membership is stored by project/group id, never by root/name, so a registry root move (see
-	// ProjectRegistryStore.registerProject) or a scope group rename needs no rewrite here at all --
-	// unlike InMemoryTaskScopeStore, this store never subscribes to root-move notifications.
+	// Membership is by project/group id, so a registry root move or group rename needs no rewrite here.
 	constructor(registry?: ProjectRegistryStore, scopeGroups?: ScopeGroupStore) {
 		this.registry = registry instanceof InMemoryProjectRegistryStore ? registry : new InMemoryProjectRegistryStore();
 		this.scopeGroups = scopeGroups ?? new InMemoryScopeGroupStore();
@@ -45,7 +43,7 @@ export class InMemoryArtifactScopeStore implements ArtifactScopeStore {
 		return { artifactId, ...(projectRoot === undefined ? {} : { projectRoot }), source: row.source };
 	}
 
-	assign(artifactId: string, projectRoot: string | undefined, source: TaskScopeSource): LegacyArtifactScope {
+	assign(artifactId: string, projectRoot: string | undefined, source: ScopeAssignmentSource): LegacyArtifactScope {
 		if (projectRoot === undefined) {
 			this.setAll(artifactId, source);
 			return { artifactId, source };
@@ -55,19 +53,19 @@ export class InMemoryArtifactScopeStore implements ArtifactScopeStore {
 		return { artifactId, projectRoot: project.projectRoot, source };
 	}
 
-	setAll(artifactId: string, source: TaskScopeSource): ArtifactScope {
+	setAll(artifactId: string, source: ScopeAssignmentSource): ArtifactScope {
 		const row: Row = { mode: "all", members: [], source };
 		this.rows.set(artifactId, row);
 		return this.toScope(artifactId, row);
 	}
 
-	setNone(artifactId: string, source: TaskScopeSource): ArtifactScope {
+	setNone(artifactId: string, source: ScopeAssignmentSource): ArtifactScope {
 		const row: Row = { mode: "none", members: [], source };
 		this.rows.set(artifactId, row);
 		return this.toScope(artifactId, row);
 	}
 
-	replaceMembers(artifactId: string, members: readonly ScopeMemberRef[], source: TaskScopeSource): ArtifactScope {
+	replaceMembers(artifactId: string, members: readonly ScopeMemberRef[], source: ScopeAssignmentSource): ArtifactScope {
 		if (members.length === 0) throw new Error("replaceMembers requires at least one member; use setAll/setNone to clear scoping");
 		if (members.length > ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT) {
 			throw new Error(`an artifact cannot have more than ${ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT} scope members`);
@@ -78,7 +76,7 @@ export class InMemoryArtifactScopeStore implements ArtifactScopeStore {
 		return this.toScope(artifactId, row);
 	}
 
-	addMember(artifactId: string, member: ScopeMemberRef, source: TaskScopeSource): ArtifactScope {
+	addMember(artifactId: string, member: ScopeMemberRef, source: ScopeAssignmentSource): ArtifactScope {
 		const existing = this.rows.get(artifactId);
 		const members = dedupeMembers(existing?.mode === "explicit" ? existing.members : []);
 		if (!members.some((candidate) => sameScopeMember(candidate, member)) && members.length >= ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT) {

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

@@ -1,16 +1,16 @@
 import { ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT } from "../constants.ts";
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
+import type { ScopeAssignmentSource } from "../project-registry/scope-source.ts";
 import { SQLiteProjectRegistryStore } from "../project-registry/sqlite-project-registry-store.ts";
 import type { ScopeMemberRef } from "../scope-group/scope-group.ts";
 import { SQLiteScopeGroupStore } from "../scope-group/sqlite-scope-group-store.ts";
-import type { TaskScopeSource } from "../task-scope/task-scope.ts";
 import type { ArtifactScope, ArtifactScopeMode, ArtifactScopeStore, LegacyArtifactScope } from "./artifact-scope-store.ts";
 
 interface ScopeRow {
 	artifact_id: string;
 	mode: ArtifactScopeMode;
-	source: TaskScopeSource;
+	source: ScopeAssignmentSource;
 }
 
 interface MemberRow {
@@ -65,7 +65,7 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 		return { artifactId, ...(project ? { projectRoot: project.projectRoot } : {}), source: row.source };
 	}
 
-	assign(artifactId: string, projectRoot: string | undefined, source: TaskScopeSource): LegacyArtifactScope {
+	assign(artifactId: string, projectRoot: string | undefined, source: ScopeAssignmentSource): LegacyArtifactScope {
 		if (projectRoot === undefined) {
 			this.setAll(artifactId, source);
 			return { artifactId, source };
@@ -77,7 +77,7 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 		});
 	}
 
-	private upsertScopeRow(artifactId: string, mode: ArtifactScopeMode, source: TaskScopeSource): void {
+	private upsertScopeRow(artifactId: string, mode: ArtifactScopeMode, source: ScopeAssignmentSource): void {
 		this.db
 			.prepare(`
 				INSERT INTO artifact_scopes (artifact_id, project_root, mode, source, assigned_at)
@@ -91,7 +91,7 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 			.run(artifactId, mode, source, new Date().toISOString());
 	}
 
-	setAll(artifactId: string, source: TaskScopeSource): ArtifactScope {
+	setAll(artifactId: string, source: ScopeAssignmentSource): ArtifactScope {
 		return inTransaction(this.db, () => {
 			this.upsertScopeRow(artifactId, "all", source);
 			this.db.prepare("DELETE FROM artifact_scope_members WHERE artifact_id = ?").run(artifactId);
@@ -99,7 +99,7 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 		});
 	}
 
-	setNone(artifactId: string, source: TaskScopeSource): ArtifactScope {
+	setNone(artifactId: string, source: ScopeAssignmentSource): ArtifactScope {
 		return inTransaction(this.db, () => {
 			this.upsertScopeRow(artifactId, "none", source);
 			this.db.prepare("DELETE FROM artifact_scope_members WHERE artifact_id = ?").run(artifactId);
@@ -107,7 +107,7 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 		});
 	}
 
-	replaceMembers(artifactId: string, members: readonly ScopeMemberRef[], source: TaskScopeSource): ArtifactScope {
+	replaceMembers(artifactId: string, members: readonly ScopeMemberRef[], source: ScopeAssignmentSource): ArtifactScope {
 		if (members.length === 0) throw new Error("replaceMembers requires at least one member; use setAll/setNone to clear scoping");
 		if (members.length > ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT) {
 			throw new Error(`an artifact cannot have more than ${ARTIFACT_SCOPE_MAX_MEMBERS_PER_ARTIFACT} scope members`);
@@ -127,7 +127,7 @@ export class SQLiteArtifactScopeStore implements ArtifactScopeStore {
 		});
 	}
 
-	addMember(artifactId: string, member: ScopeMemberRef, source: TaskScopeSource): ArtifactScope {
+	addMember(artifactId: string, member: ScopeMemberRef, source: ScopeAssignmentSource): ArtifactScope {
 		return inTransaction(this.db, () => {
 			const current = this.members(artifactId);
 			const already = current.some((candidate) => candidate.type === member.type && candidate.id === member.id);

package/src/docs/docs-service.ts

@@ -30,8 +30,8 @@ import {
 } from "../domain-service-shared.ts";
 import { NOTE_SUBTYPE } from "../note/note-service.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 { normalizeProjectRoot } from "../task-scope/task-scope.ts";
 
 function rejectsNoteTemplate(artifacts: ArtifactStore, templateId: string | undefined, subtype: string | undefined): boolean {
 	if (subtype === NOTE_SUBTYPE) return true;

package/src/domain-service-shared.ts

@@ -19,9 +19,9 @@ import {
 } from "./constants.ts";
 import { resolveProjectReference } from "./project-registry/project-registry.ts";
 import type { ProjectRegistryStore } from "./project-registry/project-registry-store.ts";
+import { normalizeProjectRoot } from "./project-registry/scope-source.ts";
 import { resolveScopeGroupReference } from "./scope-group/scope-group.ts";
 import type { ScopeGroupStore } from "./scope-group/scope-group-store.ts";
-import { normalizeProjectRoot } from "./task-scope/task-scope.ts";
 
 export interface UpdateContentInput {
 	title?: string;

package/src/gate/gate-execution.ts

@@ -1,21 +1,8 @@
 /**
- * Gate-execution engine, split out of ops.ts (the artifact-CRUD file) as part of a SOLID-audit-
- * driven decomposition (see Doc "Modularity playbook: building-block-shaped TypeScript modules
- * for papyrus/pi-papyrus" and the "gate-execution engine" child of "Epic: Modularize papyrus/
- * pi-papyrus god-files into building-block modules"). This logic was already unified in a prior
- * refactor (sync/async outcome evaluation shared via evaluateProcessGateResult/spawnErrorGateResult)
- * but still lived inside the artifact-CRUD file until now.
- *
- * Only `runGates`/`runGatesAsync` are real public API -- verified via find_references before this
- * move, not assumed from a grep hit count: the only two real importers were
- * stores/sqlite-gate-runner.ts and test/ops.test.ts (every other `runGates`-named hit in the
- * codebase is Tasks.runGates, a same-named but distinct method that calls into this module only
- * indirectly, through the GateRunner port). Both were updated to import from this file directly;
- * no barrel re-export needed.
- *
- * Depends on ops.ts's own `getArtifact` (still the right owner of that read -- it's real
- * artifact-CRUD, not gate-execution's own concern) -- a one-directional dependency, since ops.ts
- * no longer needs to import anything back from here.
+ * Gate-execution engine. `Tasks.runGates` is a separate, same-named method that calls into this
+ * module only indirectly, through the GateRunner port -- not the same thing as this file's
+ * `runGates`/`runGatesAsync`. Depends on ops.ts's `getArtifact` (real artifact-CRUD, not this
+ * module's own concern); ops.ts does not depend back on this file.
  */
 import { createRequire } from "node:module";
 import {

package/src/handlers/playbooks.ts

@@ -27,9 +27,9 @@ import { listPlaybooks } from "../playbook/playbook-service.ts";
 import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
 import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
 import type { SessionIdentity } from "../session-identity/session-identity-service.ts";
+import type { TaskEventSink } from "../task/event/task-event-store.ts";
+import type { TaskScopeAssigner } from "../task/scope/task-scope-store.ts";
 import type { Tasks } from "../task/task-service.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
-import type { TaskScopeStore } from "../task-scope/task-scope-store.ts";
 import {
 	booleanProp,
 	buildWorkflowRunContent,
@@ -53,8 +53,8 @@ const jsonObjectProp = {
 
 export interface PlaybooksVehicleDeps {
 	artifacts: ArtifactStore;
-	events: TaskEventStore;
-	scopes: TaskScopeStore;
+	events: TaskEventSink;
+	scopes: TaskScopeAssigner;
 	artifactScopes: ArtifactScopeStore;
 	tasks: Tasks;
 	sessionIdentity: SessionIdentity;

package/src/handlers/registry.ts

@@ -16,9 +16,9 @@ import type { Notes } from "../note/note-service.ts";
 import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
 import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
 import type { SessionIdentity } from "../session-identity/session-identity-service.ts";
+import type { TaskEventStore } from "../task/event/task-event-store.ts";
+import type { TaskScopeStore } from "../task/scope/task-scope-store.ts";
 import type { Tasks } from "../task/task-service.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
-import type { TaskScopeStore } from "../task-scope/task-scope-store.ts";
 import { registerArtifactTrashOperations } from "./artifact-trash.ts";
 import { registerDiscussVehicleOperations } from "./discuss.ts";
 import { registerDocsVehicleOperations } from "./docs.ts";

package/src/handlers/task-classifiers.ts

@@ -1,12 +1,4 @@
-/**
- * Business-rule error classifiers -- turn an ordinary, expected domain rejection into its own
- * classified VehicleError instead of vehicle-registry's generic opaque "handler-failed", split out
- * of handlers/shared.ts as part of a SOLID-audit-driven decomposition (see Doc "Modularity
- * playbook: building-block-shaped TypeScript modules for papyrus/pi-papyrus" and the
- * "handlers/shared.ts split" child of "Epic: Modularize papyrus/pi-papyrus god-files into
- * building-block modules"). Unlike operation-schema.ts, every function here is specific to this
- * package's own domain error types.
- */
+/** Business-rule error classifiers -- turn an ordinary, expected domain rejection into its own classified VehicleError instead of vehicle-registry's generic opaque "handler-failed". */
 import { VehicleError } from "@danypops/vehicle-core";
 import { PlaybookCompositionError } from "../playbook/playbook-definition.ts";
 import { InvalidSessionSecretError } from "../session-identity/session-identity-service.ts";

package/src/handlers/tasks.ts

@@ -28,6 +28,7 @@ import { tasksOperations } from "../modules/tasks.ts";
 import type { SessionIdentity } from "../session-identity/session-identity-service.ts";
 import { PROOF_TYPES } from "../task/checklist.ts";
 import { TaskMutationIdempotencyConflictError, TaskMutationPendingError } from "../task/mutation-request/task-mutation-request-store.ts";
+import type { TaskViewMode } from "../task/scope/task-scope.ts";
 import type { TaskExecutionPlan } from "../task/task-execution.ts";
 import {
 	type TaskCompletion,
@@ -37,7 +38,6 @@ import {
 	TaskProjectNotFoundError,
 	type Tasks,
 } from "../task/task-service.ts";
-import type { TaskViewMode } from "../task-scope/task-scope.ts";
 import {
 	booleanProp,
 	classifySessionAuthorization,

package/src/index.ts

@@ -28,7 +28,9 @@ export type { PlaybookInvocationResult, PlaybookMissingArguments } from "./playb
 export type { WorkflowRunResult } from "./playbook/workflow-execution.ts";
 export type { OperationName, SchemaState } from "./service.ts";
 export { checklistEntries, PROOF_TYPES, type ProofReference } from "./task/checklist.ts";
+export type { TaskEvent, TaskHistoryPage } from "./task/event/task-event.ts";
 export type { TaskLease, TaskLeaseView } from "./task/lease/task-lease.ts";
+export type { TaskViewSelection } from "./task/scope/task-scope.ts";
 export { taskContext } from "./task/task-context.ts";
 export { projectTaskExecution, type TaskExecutionPlan, type TaskExecutionState } from "./task/task-execution.ts";
 export { projectTaskGraph, type TaskGraphView } from "./task/task-graph-view.ts";
@@ -42,5 +44,3 @@ export type {
 	TaskStatus,
 } from "./task/task-service.ts";
 export { TaskInvalidTransitionError, TaskMutationReceiptNotFoundError } from "./task/task-service.ts";
-export type { TaskEvent, TaskHistoryPage } from "./task-event/task-event.ts";
-export type { TaskViewSelection } from "./task-scope/task-scope.ts";

package/src/modules/playbooks.ts

@@ -40,9 +40,9 @@ import {
 import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
 import type { ScopeGroupStore } from "../scope-group/scope-group-store.ts";
 import type { SessionIdentity } from "../session-identity/session-identity-service.ts";
+import type { TaskEventSink } from "../task/event/task-event-store.ts";
+import type { TaskScopeAssigner } from "../task/scope/task-scope-store.ts";
 import type { Tasks } from "../task/task-service.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
-import type { TaskScopeStore } from "../task-scope/task-scope-store.ts";
 import { type OperationInput, optionalBoolean, optionalNumber, optionalString, string } from "./operation-input.ts";
 
 const MODULE_ID = "playbooks";
@@ -105,8 +105,8 @@ export const PLAYBOOKS_OPERATION_NAMES = [
 
 export interface PlaybooksModuleDeps {
 	artifacts: ArtifactStore;
-	events: TaskEventStore;
-	scopes: TaskScopeStore;
+	events: TaskEventSink;
+	scopes: TaskScopeAssigner;
 	/** Docs/Rules/Skills/Playbooks project scoping (distinct from `scopes`, which is Task-run project scoping for playbooks.invoke's materialized tasks). */
 	artifactScopes: ArtifactScopeStore;
 	/** Used for exactly one thing: focusing the entry task after a successful invoke -- the one safety-checked Tasks operation this module needs, not bulk graph construction (that goes straight through artifacts/events/scopes in playbook/playbook-execution.ts, mirroring playbook/workflow-execution.ts). */

package/src/modules/projects.ts

@@ -11,7 +11,7 @@ import { TASK_PROJECT_LIST_MAX_RESULTS } from "../constants.ts";
 import type { OperationDefinition } from "../module-registry.ts";
 import { assertRegisterProjectInputBounds, resolveProjectReference } from "../project-registry/project-registry.ts";
 import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
-import { normalizeProjectRoot } from "../task-scope/task-scope.ts";
+import { normalizeProjectRoot } from "../project-registry/scope-source.ts";
 import { type OperationInput, optionalNumber, optionalString, optionalStringArray, string } from "./operation-input.ts";
 
 const MODULE_ID = "projects";

package/src/modules/tasks.ts

@@ -24,11 +24,11 @@ import type { ArtifactStore } from "../artifact/artifact-store.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 type { TaskEventContext, TaskEventDirection, TaskEventFeedQuery } from "../task/event/task-event.ts";
+import type { TaskViewMode } from "../task/scope/task-scope.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/playbook/playbook-service.ts

@@ -57,8 +57,8 @@ import {
 	type UpdateContentInput,
 } from "../domain-service-shared.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 { normalizeProjectRoot } from "../task-scope/task-scope.ts";
 import {
 	BLUEPRINT_INPUT_TYPES,
 	type BlueprintArgumentValue,

package/src/playbook/workflow-execution.ts

@@ -9,13 +9,13 @@ import {
 	SKILL_WORKFLOW_MAX_NESTING_DEPTH,
 	TASK_EXECUTION_MAX_EDGES,
 } from "../constants.ts";
+import { normalizeProjectRoot } from "../project-registry/scope-source.ts";
 import { validateChecklist } from "../task/checklist.ts";
+import type { TaskEventContext } from "../task/event/task-event.ts";
+import type { TaskEventSink } from "../task/event/task-event-store.ts";
+import type { TaskScopeAssigner } from "../task/scope/task-scope-store.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,
@@ -167,8 +167,8 @@ function executionGraph(tasks: Artifact[], definition: BlueprintDefinition, ids:
  * other project's context.
  */
 export type WorkflowRunHistory = {
-	events: TaskEventStore;
-	scopes: TaskScopeStore;
+	events: TaskEventSink;
+	scopes: TaskScopeAssigner;
 	artifactScopes?: ArtifactScopeStore;
 	projectRoot?: string;
 	context?: TaskEventContext;

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

@@ -0,0 +1,14 @@
+import { basename, 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. */
+export type ScopeAssignmentSource = "cwd" | "explicit" | "unscoped";
+
+export function normalizeProjectRoot(value: string): string {
+	if (!isAbsolute(value)) throw new Error("project_root must be an absolute path");
+	const normalized = normalize(value);
+	if (normalized.length > TASK_PROJECT_ROOT_MAX_LENGTH) {
+		throw new Error(`project_root cannot exceed ${TASK_PROJECT_ROOT_MAX_LENGTH} characters`);
+	}
+	return normalized;
+}

package/src/rules/rules-service.ts

@@ -31,8 +31,8 @@ import {
 	type UpdateContentInput,
 } from "../domain-service-shared.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 { normalizeProjectRoot } from "../task-scope/task-scope.ts";
 
 export interface CreateRuleInput {
 	title: string;

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

@@ -1,17 +1,10 @@
 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.
+ * A named, reusable collection of scope members (registered projects and/or other scope groups).
+ * Membership is explicit/opt-in, never path-derived: a project registered under another
+ * project's root directory (e.g. a vendored adapter package) is not automatically that parent's
+ * child -- only what's deliberately added counts.
  */
 export interface ScopeGroup {
 	id: string;

package/src/service.ts

@@ -44,16 +44,16 @@ import { SQLiteScopeGroupStore } from "./scope-group/sqlite-scope-group-store.ts
 import { InvalidSessionSecretError, SessionIdentity } from "./session-identity/session-identity-service.ts";
 import { SQLiteSessionIdentityStore } from "./session-identity/sqlite-session-identity-store.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 { type TaskStatus, Tasks } from "./task/task-service.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 { 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";
 
 /**

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

@@ -1,5 +1,5 @@
-import type { Db } from "../db.ts";
-import { inTransaction } from "../db.ts";
+import type { Db } from "../../db.ts";
+import { inTransaction } from "../../db.ts";
 import {
 	type AppendTaskEvent,
 	normalizeTaskEventFeedQuery,
@@ -13,8 +13,8 @@ import {
 	type TaskHistoryQuery,
 	type TaskLifecycleStatus,
 	validateTaskEvent,
-} from "../task-event/task-event.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
+} from "./task-event.ts";
+import type { TaskEventStore } from "./task-event-store.ts";
 
 interface TaskEventRow {
 	id: number;

package/src/{task-event → task/event}/task-event-store.ts

@@ -8,11 +8,15 @@ import {
 	type TaskHistoryPage,
 	type TaskHistoryQuery,
 	validateTaskEvent,
-} from "../task-event/task-event.ts";
+} from "./task-event.ts";
 
-export interface TaskEventStore {
+/** What a caller outside Task needs to append events -- history/feed stay on TaskEventStore since only Task's own readers use them. */
+export interface TaskEventSink {
 	atomic<T>(operation: () => T): T;
 	append(event: AppendTaskEvent): TaskEvent;
+}
+
+export interface TaskEventStore extends TaskEventSink {
 	history(taskId: string, query?: TaskHistoryQuery): TaskHistoryPage;
 	/** Bounded, sequenced, cross-task replay feed -- see TaskEventFeedQuery. */
 	feed(query?: TaskEventFeedQuery): TaskEventFeedPage;

package/src/{task-event → task/event}/task-event.ts

@@ -6,7 +6,7 @@ import {
 	TASK_EVENT_REASON_MAX_LENGTH,
 	TASK_HISTORY_DEFAULT_LIMIT,
 	TASK_HISTORY_MAX_LIMIT,
-} from "../constants.ts";
+} from "../../constants.ts";
 export type TaskLifecycleStatus = "todo" | "in-progress" | "review" | "rejected" | "done" | "canceled";
 
 export const TASK_EVENT_TYPES = [

package/src/{task-scope → task/scope}/sqlite-task-scope-store.ts

@@ -1,6 +1,6 @@
-import type { Db } from "../db.ts";
-import { inTransaction } from "../db.ts";
-import { SQLiteProjectRegistryStore } from "../project-registry/sqlite-project-registry-store.ts";
+import type { Db } from "../../db.ts";
+import { inTransaction } from "../../db.ts";
+import { SQLiteProjectRegistryStore } from "../../project-registry/sqlite-project-registry-store.ts";
 import type {
 	RegisterTaskProjectInput,
 	TaskProject,
@@ -8,8 +8,8 @@ import type {
 	TaskScopeSource,
 	TaskViewMode,
 	TaskViewPreference,
-} from "../task-scope/task-scope.ts";
-import type { TaskScopeStore } from "../task-scope/task-scope-store.ts";
+} from "./task-scope.ts";
+import type { TaskScopeStore } from "./task-scope-store.ts";
 
 /** 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 {

package/src/{task-scope → task/scope}/task-scope-store.ts

@@ -1,5 +1,5 @@
-import { InMemoryProjectRegistryStore } from "../project-registry/in-memory-project-registry-store.ts";
-import type { ProjectRegistryStore } from "../project-registry/project-registry-store.ts";
+import { InMemoryProjectRegistryStore } from "../../project-registry/in-memory-project-registry-store.ts";
+import type { ProjectRegistryStore } from "../../project-registry/project-registry-store.ts";
 import type {
 	RegisterTaskProjectInput,
 	TaskProject,
@@ -7,10 +7,14 @@ import type {
 	TaskScopeSource,
 	TaskViewMode,
 	TaskViewPreference,
-} from "../task-scope/task-scope.ts";
+} from "./task-scope.ts";
 
-export interface TaskScopeStore {
+/** What a caller outside Task needs to assign a task's project scope -- the rest of TaskScopeStore (catalog, views, listing) stays Task-only. */
+export interface TaskScopeAssigner {
 	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope;
+}
+
+export interface TaskScopeStore extends TaskScopeAssigner {
 	get(taskId: string): TaskProjectScope | undefined;
 	taskIds(projectRoot: string | undefined, limit: number): string[];
 	view(projectRoot: string): TaskViewPreference;
@@ -20,13 +24,7 @@ export interface TaskScopeStore {
 	registerProject(input: RegisterTaskProjectInput): TaskProject;
 }
 
-/**
- * Task's own scope/view bookkeeping, composing a ProjectRegistryStore for the project-catalog
- * methods (projects/matchingProjects/registerProject) rather than implementing that bookkeeping
- * itself -- see project-registry-store.ts. Pass a shared registry instance to keep Task and a
- * non-Task ArtifactScopeStore resolving against the exact same project identities; omitted, this
- * store gets its own private one (matching this class's own behavior before the extraction).
- */
+/** Pass a shared registry to keep Task and ArtifactScopeStore resolving the same project identities; omitted, this gets its own private one. */
 export class InMemoryTaskScopeStore implements TaskScopeStore {
 	private readonly scopes = new Map<string, TaskProjectScope>();
 	private readonly views = new Map<string, TaskViewPreference>();

package/src/{task-scope → task/scope}/task-scope.ts

@@ -1,9 +1,13 @@
-import { basename, isAbsolute, normalize } from "node:path";
-import { TASK_PROJECT_ROOT_MAX_LENGTH } from "../constants.ts";
-import type { Project, RegisterProjectInput } from "../project-registry/project-registry.ts";
+import { basename } from "node:path";
+import type { Project, RegisterProjectInput } from "../../project-registry/project-registry.ts";
+import type { ScopeAssignmentSource } from "../../project-registry/scope-source.ts";
+
+export { normalizeProjectRoot } from "../../project-registry/scope-source.ts";
 
 export type TaskViewMode = "project" | "graph" | "all";
-export type TaskScopeSource = "cwd" | "explicit" | "unscoped";
+
+/** Alias of ScopeAssignmentSource for Task's own call sites -- see project-registry/scope-source.ts. */
+export type TaskScopeSource = ScopeAssignmentSource;
 
 export interface TaskProjectScope {
 	taskId: string;
@@ -29,15 +33,6 @@ export interface TaskViewSelection {
 	rootTaskId?: string;
 }
 
-export function normalizeProjectRoot(value: string): string {
-	if (!isAbsolute(value)) throw new Error("project_root must be an absolute path");
-	const normalized = normalize(value);
-	if (normalized.length > TASK_PROJECT_ROOT_MAX_LENGTH) {
-		throw new Error(`project_root cannot exceed ${TASK_PROJECT_ROOT_MAX_LENGTH} characters`);
-	}
-	return normalized;
-}
-
 export function taskScopeLabel(mode: TaskViewMode, projectRoot?: string, rootTitle?: string): string {
 	if (mode === "all") return "All projects";
 	const project = projectRoot ? basename(projectRoot) || projectRoot : "Unscoped";

package/src/task/task-edges.ts

@@ -1,8 +1,8 @@
 import type { Artifact, ArtifactEdge } from "../artifact/artifact.ts";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
 import { TASK_EXECUTION_MAX_DEGREE } from "../constants.ts";
-import type { AppendTaskEvent, TaskEventContext } from "../task-event/task-event.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
+import type { AppendTaskEvent, TaskEventContext } from "./event/task-event.ts";
+import type { TaskEventStore } from "./event/task-event-store.ts";
 import { assertDependencyEdgeAllowed, TaskExecutionBoundExceededError } from "./task-execution.ts";
 // Type-only import: erased entirely at compile time, so this does not create a real runtime
 // circular dependency even though task-service.ts also imports TaskEdges (a real value) from
@@ -10,17 +10,10 @@ import { assertDependencyEdgeAllowed, TaskExecutionBoundExceededError } from "./
 import type { TaskGraph } from "./task-service.ts";
 
 /**
- * Task dependency/containment edge mutations (depend/undepend/contain/uncontain), split out of
- * the Tasks god class as part of a SOLID-audit-driven decomposition (see task b51419a0 and the
- * "TaskEdges" child of "Epic: Modularize papyrus/pi-papyrus god-files into building-block
- * modules"), mirroring the TaskLeaseCoordinator/TaskMutationCoordinator/TaskFocusCoordinator/
- * TaskProjectScope precedent in this same directory.
- *
- * Unlike those simpler extractions, this one only owns the mutation side of edges -- it reads the
- * graph/relationships it needs through injected callbacks (dependencyCheckGraph/dependencyIds/
- * relationships) rather than duplicating that graph-construction machinery, since those reads are
- * shared with concerns that stay on Tasks (list/graph/buildGraph, progress propagation, blockage
- * checks in transition/complete).
+ * Task dependency/containment edge mutations (depend/undepend/contain/uncontain). Reads the
+ * graph/relationships it needs through injected callbacks rather than owning graph construction,
+ * since those reads are shared with concerns that stay on Tasks (list/graph, progress propagation,
+ * blockage checks).
  */
 export class TaskEdges {
 	constructor(

package/src/task/task-focus-coordinator.ts

@@ -1,8 +1,8 @@
 import type { Artifact } from "../artifact/artifact.ts";
 import type { ArtifactStore } from "../artifact/artifact-store.ts";
 import { TASK_FOCUS_STALE_AFTER_MS } from "../constants.ts";
-import { type AppendTaskEvent, type TaskEventContext, validateEventContext } from "../task-event/task-event.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
+import { type AppendTaskEvent, type TaskEventContext, validateEventContext } from "./event/task-event.ts";
+import type { TaskEventStore } from "./event/task-event-store.ts";
 import type { TaskFocusStatus, TaskFocusStore } from "./focus/task-focus-store.ts";
 import { TaskInvalidTransitionError } from "./task-lifecycle-errors.ts";
 import type { TaskMutationCoordinator, TaskMutationRequestContext } from "./task-mutation-coordinator.ts";
@@ -21,14 +21,8 @@ export interface TaskFocus {
 export type TaskFocusMutationResult = TaskFocus & TaskMutationMetadata;
 
 /**
- * Task Focus (the single active/paused task per session scope), split out of the Tasks god class
- * as part of a SOLID-audit-driven decomposition (see task b51419a0 and the "TaskFocusCoordinator"
- * child of "Epic: Modularize papyrus/pi-papyrus god-files into building-block modules"), mirroring
- * the existing TaskLeaseCoordinator/TaskMutationCoordinator precedent in this same directory.
- *
- * Focus is orthogonal to lifecycle and lease: focusing a task does not start it, and does not
- * claim its lease -- so this concern has nothing to do with status transitions or worker
- * exclusivity, the other concerns that were previously interleaved with it in one class.
+ * Task Focus (the single active/paused task per session scope). Orthogonal to lifecycle and
+ * lease: focusing a task does not start it and does not claim its lease.
  */
 export class TaskFocusCoordinator {
 	constructor(

package/src/task/task-lease-coordinator.ts

@@ -3,12 +3,9 @@ import type { TaskLease, TaskLeaseView } from "./lease/task-lease.ts";
 import type { TaskLeaseStore } from "./lease/task-lease-store.ts";
 
 /**
- * Task lease management (claim/heartbeat/release/get/reap), split out of the Tasks god class as
- * part of a SOLID-audit-driven decomposition (see task b51419a0). A lease is orthogonal to
- * lifecycle and Focus -- claiming a task does not start it, and does not require it to be
- * Focused -- so its own concern (a single active worker per task, TTL-based) has nothing to do
- * with status transitions, idempotency receipts, or checklist review, the other concerns that
- * were previously interleaved with it in one class.
+ * Task lease management (claim/heartbeat/release/get/reap) -- a single active worker per task,
+ * TTL-based. Orthogonal to lifecycle and Focus: claiming a task does not start it or require it
+ * to be Focused.
  */
 export class TaskLeaseCoordinator {
 	constructor(

package/src/task/task-mutation-coordinator.ts

@@ -41,26 +41,16 @@ function canonicalJson(value: unknown): string {
 }
 
 /**
- * Idempotency-key-backed mutation receipt plumbing, split out of the Tasks god class as part of
- * a SOLID-audit-driven decomposition (see task b51419a0). Owns reserving a "pending" receipt
- * before a real mutation runs, replaying an already-completed one, rejecting a genuinely
- * different payload reused under the same key, and rejecting a NEW attempt against a
- * task+operation that already has one in flight.
+ * Idempotency-key-backed mutation receipt plumbing: reserves a "pending" receipt before a real
+ * mutation runs, replays an already-completed one, rejects a different payload reused under the
+ * same key, and rejects a new attempt against a task+operation that already has one in flight.
  *
- * `validate`, when supplied to prepare(), runs before anything else -- including before the
- * existing/replay lookup -- specifically so a caller-supplied validation failure (e.g. an
- * over-length `reason`) can never leave a receipt reserved with no way to ever mark it complete.
- * This is the direct fix for a real incident (task a54f0649, discovered live completing task
- * d0eb81b7): validation previously ran deep inside the CALLER's own atomic block (appendEvent's
- * own validateTaskEvent), strictly AFTER prepare()'s reserving call had already durably written
- * the receipt as pending. Once that validation threw, nothing downstream ever reached the code
- * path that marks a receipt complete, permanently stranding it -- and since the pending-mutation
- * lock is keyed on (taskId, operation) rather than the idempotency key, that stuck receipt then
- * blocked every subsequent attempt on the same task+operation, under ANY key, until the record's
- * 7-day retention window expired. No self-service recovery existed; the live incident required a
- * direct database row deletion. Every caller that can determine its own event-context validity up
- * front (reason/sessionId length, at minimum) should now pass a `validate` callback here instead
- * of only validating once real mutation work is already underway.
+ * `validate`, when passed to prepare(), runs before the existing/replay lookup, so a
+ * caller-supplied validation failure can never leave a receipt reserved with no way to complete
+ * it -- a stuck pending receipt blocks every later attempt on that task+operation, under any key,
+ * until its retention window expires, with no self-service recovery. Any caller that can
+ * determine its own event-context validity up front should pass `validate` here rather than
+ * validating only once real mutation work is underway.
  */
 export class TaskMutationCoordinator {
 	constructor(

package/src/task/task-project-scope.ts

@@ -1,8 +1,8 @@
 import type { Artifact } from "../artifact/artifact.ts";
 import { TASK_PROJECT_LIST_MAX_RESULTS } from "../constants.ts";
 import { assertRegisterProjectInputBounds } from "../project-registry/project-registry.ts";
-import type { AppendTaskEvent, TaskEventContext } from "../task-event/task-event.ts";
-import type { TaskEventStore } from "../task-event/task-event-store.ts";
+import type { AppendTaskEvent, TaskEventContext } from "./event/task-event.ts";
+import type { TaskEventStore } from "./event/task-event-store.ts";
 import {
 	normalizeProjectRoot,
 	type RegisterTaskProjectInput,
@@ -10,21 +10,16 @@ import {
 	type TaskViewMode,
 	type TaskViewSelection,
 	taskScopeLabel,
-} from "../task-scope/task-scope.ts";
-import type { TaskScopeStore } from "../task-scope/task-scope-store.ts";
+} from "./scope/task-scope.ts";
+import type { TaskScopeStore } from "./scope/task-scope-store.ts";
 
 export class TaskProjectNotFoundError extends Error {}
 export class TaskProjectAmbiguousError extends Error {}
 
 /**
  * Task project-scope management (scopeSelection/setView/assignProject/projects/resolveProject/
- * registerProject), split out of the Tasks god class as part of a SOLID-audit-driven
- * decomposition (see task b51419a0 and the "TaskProjectScope" child of "Epic: Modularize
- * papyrus/pi-papyrus god-files into building-block modules"), mirroring the existing
- * TaskLeaseCoordinator/TaskMutationCoordinator/TaskFocusCoordinator precedent in this directory.
- *
- * list()/graph() (which stay on Tasks -- they're core query/graph-construction, not project-scope
- * itself) still call scopeSelection() on this collaborator via Tasks' own thin delegation.
+ * registerProject). list()/graph() stay on Tasks but still call scopeSelection() here via a thin
+ * delegation, since those are core query/graph-construction, not project-scope itself.
  */
 export class TaskProjectScope {
 	constructor(

package/src/task/task-service.ts

@@ -18,6 +18,12 @@ import { DISCUSSION_SUBTYPE, isDiscussionArtifact, readDiscussionExtra } from ".
 import type { TransitionTable } from "../domain-service-shared.ts";
 import { type Gate, type GateResult, validateGates } from "../gate/gate.ts";
 import type { GateRunner } from "../gate/gate-runner.ts";
+import { type Checklist, checklistEntries, type ProofReference, validateChecklist } from "./checklist.ts";
+import {
+	InMemoryTaskCreateRequestStore,
+	TaskCreateIdempotencyConflictError,
+	type TaskCreateRequestStore,
+} from "./create-request/task-create-request-store.ts";
 import type {
 	AppendTaskEvent,
 	TaskEventContext,
@@ -26,25 +32,9 @@ import type {
 	TaskHistoryPage,
 	TaskHistoryQuery,
 	TaskLifecycleStatus,
-} from "../task-event/task-event.ts";
-import { validateEventContext } from "../task-event/task-event.ts";
-import { InMemoryTaskEventStore, type TaskEventStore } from "../task-event/task-event-store.ts";
-import {
-	normalizeProjectRoot,
-	type RegisterTaskProjectInput,
-	type TaskProject,
-	type TaskScopeSource,
-	type TaskViewMode,
-	type TaskViewSelection,
-	taskScopeLabel,
-} from "../task-scope/task-scope.ts";
-import { InMemoryTaskScopeStore, type TaskScopeStore } from "../task-scope/task-scope-store.ts";
-import { type Checklist, checklistEntries, type ProofReference, validateChecklist } from "./checklist.ts";
-import {
-	InMemoryTaskCreateRequestStore,
-	TaskCreateIdempotencyConflictError,
-	type TaskCreateRequestStore,
-} from "./create-request/task-create-request-store.ts";
+} from "./event/task-event.ts";
+import { validateEventContext } from "./event/task-event.ts";
+import { InMemoryTaskEventStore, type TaskEventStore } from "./event/task-event-store.ts";
 import { InMemoryTaskFocusStore, type TaskFocusStatus, type TaskFocusStore } from "./focus/task-focus-store.ts";
 import type { TaskLeaseView } from "./lease/task-lease.ts";
 import { InMemoryTaskLeaseStore, type TaskLeaseStore } from "./lease/task-lease-store.ts";
@@ -54,6 +44,16 @@ import {
 	type TaskMutationRequestRecord,
 	type TaskMutationRequestStore,
 } from "./mutation-request/task-mutation-request-store.ts";
+import {
+	normalizeProjectRoot,
+	type RegisterTaskProjectInput,
+	type TaskProject,
+	type TaskScopeSource,
+	type TaskViewMode,
+	type TaskViewSelection,
+	taskScopeLabel,
+} from "./scope/task-scope.ts";
+import { InMemoryTaskScopeStore, type TaskScopeStore } from "./scope/task-scope-store.ts";
 import { TaskEdges } from "./task-edges.ts";
 import { TaskExecutionBoundExceededError } from "./task-execution.ts";
 import { type TaskFocus, TaskFocusCoordinator, type TaskFocusMutationResult } from "./task-focus-coordinator.ts";