feat: public projects, project deletion and sagas

Public projects:
- Project.isPublic (create/update, owners and admins). Anyone can read a
  public project without a token: project, board, tickets, comments,
  history, releases, activity, tracking and statistics, over GraphQL and
  REST. Writes stay for members (401 anonymous, 403 outsiders).
- @OptionalAuth() / @ApiOptionalPireonAuth(): anonymous callers allowed,
  invalid tokens still rejected. ReadAccess lets anonymous viewers read
  public projects only; linked tickets are filtered by visibility.
- publicProjects (GraphQL) and GET /api/explore/projects (REST).
- Web: «Explorar» page, project pages open without a session (read-only
  notice, sign-in hints), public badge, visibility switch in settings,
  no realtime subscriptions without a session.

Project deletion:
- Owner only, confirming the key (deleteProject / DELETE
  /api/projects/{project}?confirm=KEY). The key is freed; the read model
  drops the project and members are notified (web goes home).

Sagas (run by the EventsBridge after projections, durable and ordered):
- ProjectDeletionSaga: project deleted → delete its tickets and releases;
  ticket deleted → purge its comments and drop links from other tickets.
- ReleaseArchivedSaga: unfinished tickets leave an archived release.
- UserDeactivatedSaga: the Pireon webhook records UserDeactivatedEvent in
  the event store (EventRecorder); the tracker unassigns that user's open
  tickets as the system actor.
- Internal idempotent commands; domain refusals are logged and skipped,
  concurrency conflicts retried. Affected streams come from the event store
  (TrackerStreamsRepository).

Tests: domain lifecycle specs, saga specs run like the bridge, facade
tests, e2e for public access, cascade deletion, archived releases and
deactivation webhook. Docs, READMEs, schema.gql/openapi.json and Word/PDF
updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

libs/api/tracker/domain/src/lib/project/project.ts

@@ -5,6 +5,7 @@ import {
   assertThat,
 } from '@task-stream/api/shared/domain';
 import { ProjectCreatedEvent } from '../events/project-created.event';
+import { ProjectDeletedEvent } from '../events/project-deleted.event';
 import { ProjectMemberAddedEvent } from '../events/project-member-added.event';
 import { ProjectMemberRemovedEvent } from '../events/project-member-removed.event';
 import { ProjectMemberRoleChangedEvent } from '../events/project-member-role-changed.event';
@@ -29,6 +30,8 @@ export interface ProjectProps {
   key: string;
   name: string;
   description: string | null;
+  /** Anyone (even without signing in) can read it. Absent in old projects: private. */
+  isPublic?: boolean;
   ownerId: string;
   members: ProjectMember[];
   /** Absent in projects created before settings existed: defaults apply. */
@@ -45,11 +48,14 @@ export class Project extends VersionedAggregateRoot implements ProjectProps {
   public key!: string;
   public name!: string;
   public description: string | null = null;
+  public isPublic = false;
   public ownerId!: string;
   public members: ProjectMember[] = [];
   public settings: ProjectSettings = defaultProjectSettings();
   public createdAt!: string;
   public updatedAt!: string;
+  /** Set once deleted: the project can no longer be loaded for commands. */
+  public deleted = false;
 
   constructor(id: string) {
     super();
@@ -69,16 +75,18 @@ export class Project extends VersionedAggregateRoot implements ProjectProps {
     return this.roleOf(userId) !== null;
   }
 
-  /** Can read the project. */
+  /** Can read the project: members, or anyone if it is public. */
   assertCanView(userId: string): void {
-    if (!this.isMember(userId)) {
+    if (!this.isPublic && !this.isMember(userId)) {
       throw new ForbiddenError(`You are not a member of project ${this.key}`);
     }
   }
 
-  /** Can create and modify tickets, comments, links... */
+  /** Can create and modify tickets, comments, links... (members only, even if public). */
   assertCanContribute(userId: string): void {
-    this.assertCanView(userId);
+    if (!this.isMember(userId)) {
+      throw new ForbiddenError(`You are not a member of project ${this.key}`);
+    }
     if (this.roleOf(userId) === ProjectRole.VIEWER) {
       throw new ForbiddenError(`Viewers cannot modify project ${this.key}`);
     }
@@ -96,10 +104,14 @@ export class Project extends VersionedAggregateRoot implements ProjectProps {
 
   updateDetails(
     actorId: string,
-    changes: { name?: string; description?: string | null },
+    changes: { name?: string; description?: string | null; isPublic?: boolean },
   ): void {
     this.assertCanManage(actorId);
-    const patch: { name?: string; description?: string | null } = {};
+    const patch: {
+      name?: string;
+      description?: string | null;
+      isPublic?: boolean;
+    } = {};
     if (changes.name !== undefined) {
       const name = changes.name.trim();
       assertThat(name.length > 0, 'Project name is required');
@@ -109,10 +121,35 @@ export class Project extends VersionedAggregateRoot implements ProjectProps {
       const description = changes.description?.trim() || null;
       if (description !== this.description) patch.description = description;
     }
+    if (changes.isPublic !== undefined && changes.isPublic !== this.isPublic)
+      patch.isPublic = changes.isPublic;
     if (Object.keys(patch).length === 0) return;
     this.apply(new ProjectUpdatedEvent(actorId, this.id, patch));
   }
 
+  /**
+   * Only the owner deletes a project, confirming its key. Tickets, comments
+   * and releases follow (cascade saga); the events stay in the store.
+   */
+  delete(actorId: string, confirmKey: string): void {
+    if (actorId !== this.ownerId) {
+      throw new ForbiddenError(`Only the owner can delete project ${this.key}`);
+    }
+    if (confirmKey.trim().toUpperCase() !== this.key) {
+      throw new BusinessRuleError(
+        `Type the project key (${this.key}) to confirm the deletion`,
+      );
+    }
+    this.apply(
+      new ProjectDeletedEvent(
+        actorId,
+        this.id,
+        this.key,
+        this.members.map((m) => m.userId),
+      ),
+    );
+  }
+
   /** Owners and admins customise statuses, transitions, types and areas. */
   updateSettings(actorId: string, next: ProjectSettings): void {
     this.assertCanManage(actorId);
@@ -175,6 +212,7 @@ export class Project extends VersionedAggregateRoot implements ProjectProps {
     this.key = project.key;
     this.name = project.name;
     this.description = project.description;
+    this.isPublic = project.isPublic ?? false;
     this.ownerId = project.ownerId;
     this.members = project.members.map((m) => ({ ...m }));
     this.settings = structuredClone(
@@ -189,6 +227,10 @@ export class Project extends VersionedAggregateRoot implements ProjectProps {
     this.updatedAt = event.occurredAt;
   }
 
+  onProjectDeletedEvent(): void {
+    this.deleted = true;
+  }
+
   onProjectSettingsChangedEvent(event: ProjectSettingsChangedEvent): void {
     this.settings = structuredClone(event.settings);
     this.updatedAt = event.occurredAt;