@cplace/test-mcp-server 1.0.0 → 1.1.0

package/dist/widget-specifications/_research_from_ga_products/cf-cplace-projectTree-editProjects/research.md

@@ -0,0 +1,163 @@
+# Widget Research: cf.cplace.projectTree.editProjects
+
+## Overview
+
+**Widget ID:** `cf.cplace.projectTree.editProjects`
+**Widget Name:** Edit Project Structure
+**Repository:** `cplace-project-planning`
+**Definition Class:** `cf.cplace.projectTree/src/main/java/cf/cplace/projectTree/script/EditProjectHierarchyWidgetDefinition.java`
+**Plugin:** `cf.cplace.projectTree` (Project Structure)
+
+## Purpose
+
+The "Edit Project Structure" widget provides an interactive tree view for visualizing and managing the hierarchical structure of projects and schedules. It enables users to create, reorganize, and manage project hierarchies through drag-and-drop functionality, allowing restructuring of projects and schedules within the project tree.
+
+**Short Description:** Displays a hierarchical tree of projects and schedules, allowing users to create subprojects, create schedules, and reorganize the project structure via drag-and-drop.
+
+## Core Functionality
+
+### What It Does
+
+1. **Displays Project Hierarchy as a Tree**
+   - Shows projects and their subprojects in an expandable/collapsible tree structure
+   - Shows schedules associated with each project
+   - Displays both direct children and "additionally linked" projects/schedules (shown with a special icon)
+
+2. **Enables Drag-and-Drop Reorganization**
+   - Move projects to different parent projects
+   - Move schedules to different parent projects
+   - Reorder projects within the same parent (projects maintain an order index)
+   - Move additionally linked items between parents
+
+3. **Provides Context Menu Actions**
+   - Create Subproject (direct creation)
+   - Create Subproject from Template
+   - Create Schedule (new or from template)
+   - Delete project/schedule
+   - Open in new tab
+   - Unlink project (for additionally linked items)
+
+### Key Technical Details
+
+- Uses `ProjectsTreeContentProvider` to fetch and organize tree data
+- Implements `CanMoveHandler` and `MoveHandler` for drag-and-drop validation and execution
+- Supports both primary parent relationships and "Additional Project Links" (secondary relationships for cross-references)
+- Tree roots are initially expanded; child nodes load on demand
+- Respects access permissions - only shows items the user can read
+
+## Use Cases
+
+### Primary Use Cases
+
+1. **Portfolio Management Dashboard**
+   - PMO teams use this widget to get a visual overview of all projects
+   - Navigate the project hierarchy to find specific projects or schedules
+   - Restructure projects as organizational needs change
+
+2. **Project Reorganization**
+   - Move a project to a new parent project when organizational structure changes
+   - Move schedules between projects when scope or responsibility shifts
+   - Clean up project hierarchies by deleting unused projects
+
+3. **New Project/Schedule Creation**
+   - Create subprojects directly under a parent project
+   - Create schedules from templates within the project structure
+   - Build out project hierarchies with nested subprojects
+
+4. **Cross-Project Relationships**
+   - View projects that appear in multiple locations via "Additional Project Links"
+   - Manage thematic relationships between projects without changing the primary hierarchy
+
+### When to Use This Widget
+
+- **Use when:** Users need to manage the overall project structure, create new projects/schedules, or reorganize existing hierarchies
+- **Placement:** Typically on a dedicated "Project Structure" or "Portfolio" page, or on a project's dashboard to show its subprojects
+
+### Problems It Solves
+
+- Provides a visual representation of complex project hierarchies that would be hard to understand in a flat list
+- Enables restructuring without navigating to individual project pages
+- Centralizes project/schedule creation actions in one interface
+- Shows cross-linked projects without duplicating the actual project data
+
+## Configuration Options
+
+### Main Configuration Attributes
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `title` | LocalizedString | Optional custom title for the widget. If not set, uses the default widget name. |
+| `rootProjects` | Multi-page reference | Explicitly selected root projects to display. If empty, shows all projects without a parent. |
+| `rootProjectsSearch` | Search | A search query to find additional root projects. Results are appended to explicitly selected projects. The search automatically filters for projects only. |
+| `height` | Number | Fixed height for the widget. Height adapts if context menu doesn't fit. |
+
+### Configuration Modes
+
+1. **Default Mode (no configuration)**
+   - Shows all root-level projects (projects without a parent) across all workspaces with the Project Structure app
+   - Useful for organization-wide portfolio views
+
+2. **Filtered by Selection**
+   - Explicitly select specific projects as roots
+   - Only those projects and their children appear in the tree
+   - Useful for focused views on specific project groups
+
+3. **Filtered by Search**
+   - Define a search query to dynamically find root projects
+   - Can combine with explicit selections (explicit + search results)
+   - Useful for dynamic views based on project attributes
+
+### Important Behaviors
+
+- If configured root projects exist but the user cannot see them (permissions), shows an info message about invisible projects
+- Root projects from search are sorted alphabetically
+- Direct children projects are sorted by order index (manually orderable)
+- Schedules are sorted by name
+
+## Related Components
+
+### Part of Larger Feature Set
+
+This widget is part of the **Project Structure** (`cf.cplace.projectTree`) app, which includes:
+
+- **Project type** with parent/child relationships and "Additional Project Links"
+- **Schedule parent-project reference** for organizing schedules under projects
+- **Project Structure Editor role** for users who can restructure projects but not edit their content
+- **Template-based creation** for projects and schedules
+
+### Related Widgets (same plugin)
+
+This is the primary widget for the Project Structure plugin. Other related components include:
+- Tree reference explorers for selecting projects/schedules in reference fields
+- Context menu handlers for project/schedule operations
+
+### Dependencies
+
+- **cf.cplace.planauswahl** - Provides the tree view infrastructure and base classes
+- **cf.cplace.projektplanung** - Provides Schedule type definitions
+
+### Prerequisites
+
+- The **Project Structure** app must be installed in the workspace
+- Projects and Schedules must have the standard type definitions from the Project Planning solution
+
+## Additional Notes
+
+### Permission Handling
+
+- The widget validates permissions before allowing moves
+- Prevents moving a project into its own subtree (circular reference)
+- Checks `maySetAsParent` permission for projects
+- Validates attribute constraints (validators) on parent/link attributes
+- Respects the "Project Structure Editor" role for restructuring permissions
+
+### Display Considerations
+
+- "Linked" items (via Additional Project Links) display with a different icon to distinguish them from direct children
+- Schedules appear before subprojects within each project node
+- The tree uses lazy loading for children to maintain performance with large hierarchies
+
+### Localization
+
+- Widget name: "Edit Project Structure" (en), "Projektstruktur bearbeiten" (de, assumed)
+- Widget description: "Lets you create and manage schedules and projects in the project structure tree."

package/dist/widget-specifications/_research_from_ga_products/cf-cplace-projektplanung-scheduleLockState/research.md

@@ -0,0 +1,174 @@
+# Widget Research: cf.cplace.projektplanung.scheduleLockState
+
+## Widget Overview
+
+**Widget ID:** `cf.cplace.projektplanung.scheduleLockState`
+
+**Repository:** `cplace-project-planning`
+
+**Definition Class:** `cf.cplace.projektplanung.script.ScheduleLockStateWidgetDefinition`
+
+## Purpose
+
+This widget displays the current lock state of a schedule element, showing whether a schedule is locked, who locked it, when it was locked, which schedules are affected, and provides controls to release the lock.
+
+## Description
+
+The Schedule Lock State widget shows the current `ScheduleLock` state of a schedule element. It provides visibility into which schedules are currently locked for editing, who owns the lock, and allows authorized users to release locks when needed.
+
+## Core Functionality
+
+### What is Schedule Locking?
+
+Schedule locking is a feature that prevents write access to schedules and their tasks for everyone except the lock owner. Key aspects:
+
+- **Lock Ownership:** The creator of the lock becomes the owner
+- **Exclusive Access:** Only the lock owner can edit locked schedules and their tasks
+- **Multiple Schedules:** A single lock can apply to multiple schedules simultaneously
+- **Authorization-Based:** Locks can be created and released by authorized users (schedule writers, owners, deputies, space administrators)
+- **Token-Based:** Each lock has a unique token (ID + secret) for identification
+
+### Widget Display States
+
+The widget has two primary display states:
+
+1. **Locked State**
+   - Displays "Locked" indicator
+   - Shows who created the lock with a link to their profile
+   - Shows when the lock was created
+   - Lists all schedules affected by this lock
+   - Provides a "Release Lock" button (if user has permission)
+
+2. **Unlocked State**
+   - Displays "Unlocked" indicator
+   - No additional information or actions
+
+## Use Cases
+
+### 1. Schedule Lock Visibility
+
+**Scenario:** A project manager wants to know if a schedule is currently locked and by whom.
+
+**Value:** The widget provides immediate visibility into the lock status without requiring users to attempt edits or navigate elsewhere. Users can see:
+- Whether the schedule is locked or available
+- Who owns the lock
+- When the lock was created
+- Which schedules are affected
+
+### 2. Lock Release Management
+
+**Scenario:** A schedule administrator needs to release a lock that is no longer needed or was left active by a user who is unavailable.
+
+**Value:** Authorized users (lock creator, schedule writers, space administrators) can release locks directly from the widget through the "Release Lock" button, which:
+- Opens a confirmation dialog
+- Allows release of the lock
+- Restores edit access to all users
+
+### 3. Multi-Schedule Lock Tracking
+
+**Scenario:** When working with Gantt charts that load multiple schedules, users need to understand which schedules are locked together.
+
+**Value:** The widget displays all schedules affected by a single lock, helping users understand the scope of the lock and its impact on their work.
+
+### 4. Lock Accountability
+
+**Scenario:** Teams need to track who is making changes to critical schedules.
+
+**Value:** The widget provides transparency by showing:
+- Lock creator identity
+- Lock creation timestamp
+- Affected schedules
+
+This creates accountability and helps coordinate collaborative editing of project schedules.
+
+## Configuration
+
+### Embedding Restrictions
+
+The widget can only be embedded in specific entity types:
+- **Activities** (`cf.activity` / `cf.cplace.projektplanung.aktivitaet`)
+- **Milestones** (`cf.milestone` / `cf.cplace.projektplanung.meilenstein`)
+- **Schedules** (`cf.schedule` / `cf.cplace.projektplanung.schedule`)
+
+### Prerequisites
+
+- **Schedule Locking Must Be Enabled:** The widget will not be embeddable unless schedule locking is activated in the system (checked via `ProjektplanungPlugin.isScheduleLockingEnabled()`)
+- **Logged-in User Required:** Users must be authenticated to view the widget content
+- **Permission-Based Actions:** The "Release Lock" button is only displayed if the user has permission to release the lock
+
+### Widget Behavior
+
+- **Dynamic Content Loading:** Widget content is loaded via AJAX from `ScheduleLockStateWidgetContentHandler`
+- **Context-Aware:** Automatically detects the lock for the containing schedule of the embedding entity
+- **No Configuration Options:** The widget does not expose configuration parameters - it automatically shows the lock state of the schedule containing the page where it's embedded
+
+## Technical Details
+
+### Lock Resolution
+
+The widget resolves the lock by:
+1. Identifying the embedding page (activity, milestone, or schedule)
+2. Finding the containing schedule using `ScheduleUtil.findScheduleOfGanttElement()`
+3. Retrieving the lock associated with that schedule via `ScheduleLock.getLockForContainingSchedule()`
+
+### Permissions Model
+
+Lock access follows this permission model:
+- **Read Access:** Granted to lock creator and all writers of locked schedules (owners, deputies, space administrators)
+- **Write/Release Access:** Same as read access
+- **Fast Path:** If current user is the lock creator, permission is immediately granted
+- **Automatic Updates:** Permission changes to schedules may not immediately reflect in lock permissions
+
+### Lock Lifecycle
+
+1. **Creation:** Locks are created via `CreateScheduleLockHandler` for one or more schedules
+2. **Display:** This widget displays the current lock state
+3. **Release:** Users with permission can release locks via `ConfirmReleaseScheduleLockHandler` and `SubmitReleaseScheduleLockHandler`
+4. **Removal:** Releasing a lock removes the lock entity from the system
+5. **Logging:** All lock operations (create, update, release) are logged with user and schedule details
+
+## Related Features
+
+### Schedule Locking Feature Set
+
+This widget is part of the broader schedule locking feature:
+- **Lock Creation Handlers:** `CreateScheduleLockHandler`, `CreateExpirableScheduleLockHandler`
+- **Lock Management:** `UpdateScheduleLockHandler`, `ReleaseScheduleLockHandler`
+- **Lock Prevention:** `ScheduleLockPreventRemovePageByHandlerExtension` prevents deletion of locked schedules
+- **Expirable Locks:** Support for locks that automatically expire after a certain time
+
+### Integration with Gantt Charts
+
+Schedule locking is tightly integrated with Gantt chart functionality:
+- Locks can be created from within Gantt views
+- Multiple schedules loaded in Gantt can be locked together
+- Lock state affects editing capabilities in Gantt views
+
+### WorkPackage Association
+
+Locks are associated with schedules through the `WorkPackage` mixin:
+- Each schedule has a `scheduleLocks` reference (via WorkPackage mixin)
+- This allows schedules to be associated with locks
+- The widget uses this relationship to display lock information
+
+## Key Insights
+
+1. **Read-Only Display:** The widget is primarily informational - it shows lock state and provides a release action, but does not handle lock creation
+
+2. **No Configuration Required:** Unlike many widgets, this one requires no configuration - it automatically detects and displays the relevant lock state
+
+3. **Security-Conscious:** The widget respects permission boundaries and only shows release controls to authorized users
+
+4. **Gantt-Centric:** While embeddable in activities, milestones, and schedules, the feature is designed for project planning and Gantt chart workflows
+
+5. **Coordination Tool:** The widget serves as a coordination mechanism for teams working on shared schedules, providing visibility and control over who can make changes
+
+6. **Feature Flag:** The entire schedule locking feature can be toggled on/off, and the widget respects this system-wide setting
+
+## Potential Questions for Documentation
+
+1. **Scope:** Should documentation cover just the widget, or also explain the broader schedule locking feature?
+2. **User Types:** Should we document different perspectives (schedule editors vs. administrators)?
+3. **Screenshots:** Would it be helpful to include screenshots of locked vs. unlocked states?
+4. **Workflow:** Should we document the typical workflow (create lock → work → release lock)?
+5. **Best Practices:** Should we include guidance on when to use schedule locking?

package/dist/widget-specifications/_research_from_ga_products/cf-cplace-projektplanung-subscriptions/research.md

@@ -0,0 +1,316 @@
+# Widget Research: cf.cplace.projektplanung.subscriptions
+
+**Research Date:** 2026-01-16
+**Widget ID:** `cf.cplace.projektplanung.subscriptions`
+**Repository:** `cplace-project-planning`
+**Definition Class:** `cf.cplace.projektplanung/src/main/java/cf/cplace/projektplanung/script/SubscriptionsWidgetDefinition.java`
+
+---
+
+## 1. Widget Purpose
+
+### Short Description (1-2 sentences)
+The Subscriptions widget displays all subscriptions of a planning element (task or milestone) in a table format. It shows which other schedules contain subscribed copies of the current task/milestone, providing visibility into cross-schedule task references.
+
+### Detailed Purpose
+This widget is part of the "Project Planning (Extended)" app and provides a specialized view for managing task/milestone subscriptions. A subscription (German: "Abo") is essentially a mirror/copy of a task or milestone that exists in another schedule. The widget displays:
+- All subscriptions of the current planning element
+- Information about read access to subscriptions
+- Parent schedule and containing schedule information for each subscription
+- Visual indicators for subscriptions the user cannot access
+
+The widget helps users understand where their tasks are being referenced across different project schedules, enabling better coordination in multi-schedule project environments.
+
+---
+
+## 2. Use Cases
+
+### Primary Use Case: Cross-Schedule Task Visibility
+**Scenario:** A project manager has a master task in Schedule A, and this task has been subscribed to (referenced) by tasks in Schedules B and C.
+
+**Problem Solved:** Without this widget, users would have no easy way to see all the places where their task is being referenced across different schedules.
+
+**User Action:** The project manager opens the task in Schedule A and views the Subscriptions widget to see all subscriptions across other schedules.
+
+**Value:** Provides transparency and traceability for cross-schedule dependencies and task sharing.
+
+### Secondary Use Case: Access Control Awareness
+**Scenario:** A task has multiple subscriptions, but the current user only has read access to some of the schedules containing those subscriptions.
+
+**Problem Solved:** Users need to understand which subscriptions they can view and which they cannot access due to permissions.
+
+**User Action:** The widget displays counts showing:
+- Total subscriptions: X
+- Visible subscriptions: Y of X
+- Subscriptions without read access: Z
+
+**Value:** Helps users understand the complete picture while respecting security boundaries.
+
+### Tertiary Use Case: Hierarchical Task Subscription Management
+**Scenario:** In hybrid project management environments, tasks can be subscribed from one schedule to another, creating a network of related planning elements.
+
+**Problem Solved:** Understanding the subscription hierarchy and relationships between original tasks and their subscribed copies.
+
+**User Action:** Users can see the subscription structure and trace back to containing schedules.
+
+**Value:** Enables better coordination in complex multi-schedule project environments.
+
+---
+
+## 3. Configuration Options
+
+### Available Configuration Attributes
+
+#### 3.1 TITLE (Optional)
+- **Type:** `SingleLocalizedStringAttributeDef`
+- **Attribute Name:** `cf.cplace.projektplanung.subscriptions.title`
+- **Purpose:** Allows customization of the widget title
+- **Default:** "Subscriptions" (English) / "Abos" (German)
+- **Behavior:** If not set, falls back to the default localized title
+
+#### 3.2 HEIGHT (Optional)
+- **Type:** `SingleNumberAttributeDef`
+- **Purpose:** Defines the fixed height of the widget
+- **Inherited From:** `WidgetTypes.BASE_MIXIN.HEIGHT`
+- **Behavior:** Allows users to control the vertical space allocated to the widget
+
+### Configuration Type
+- **Type Definition:** `cf.cplace.projektplanung.WidgetTypes.SUBSCRIPTIONS.TYPE`
+- **Internal Type Name:** Uses `SubscriptionsWidgetDefinition.WIDGET_TYPE_SUBSCRIPTIONS`
+
+### Display Modes and Limits
+
+#### Subscription Display Limit
+- **Maximum Subscriptions:** 500 (`MAX_SUBSCRIPTIONS_IN_WIDGET`)
+- **Reason:** Performance optimization - search operations have clause limits
+- **Behavior:** If more than 500 subscriptions exist, only the first 500 (with read access) are displayed
+- **User Feedback:** Widget shows message "Visible subscriptions: X of Y (limited by widget)"
+
+#### Access-Based Display
+The widget intelligently handles permissions:
+1. Counts total subscriptions (including those without read access)
+2. Determines how many the user can actually read
+3. Applies the 500-item limit to viewable subscriptions
+4. Displays appropriate message based on these counts:
+   - "Total subscriptions: X" (when all are visible)
+   - "Visible subscriptions: X of Y" (when some are hidden due to access)
+   - "Visible subscriptions: X of Y (limited by widget)" (when 500 limit is hit)
+   - "Subscriptions without read-access: Z" (additional info)
+
+---
+
+## 4. Technical Implementation Details
+
+### Widget Definition Class
+- **Location:** `cf.cplace.projektplanung.script.SubscriptionsWidgetDefinition.java`
+- **Extends:** `WidgetDefinition`
+- **Implements:** `SingleSelectionWidget`
+- **App Context:** ProjektplanungPlugin.INSTANCE().extendedApp
+
+### Specification Handler
+- **Class:** `SubscriptionsSpecificationHandler`
+- **Extends:** `GenericSearchAsTableSpecificationHandler`
+- **Purpose:** Constructs the table search query to fetch subscriptions
+
+### Data Source
+The widget retrieves subscriptions through:
+```java
+Page page = Page.getPageByUidNotNull(params.entityUid);
+mirrorCountTotal = page._entityMirrors().count();
+mirrorCountReadAccess = Lists.newArrayList(page._entityMirrors().getAssets()).size();
+```
+
+### Search Construction
+The table search:
+1. Filters by type: `AKTIVITAET.TYPE` or `MEILENSTEIN.TYPE`
+2. Filters by UIDs from entity mirrors
+3. Limits to 500 subscriptions maximum
+
+### Default Table Columns
+The widget displays these columns by default:
+- Parent (cf.cplace.projektplanung.Aktivitaet.parent)
+- Containing Schedule (cf.cplace.projektplanung.Aktivitaet.containingSchedule)
+
+### Widget Padding
+- **noPadding:** `true`
+- **Reason:** The table component handles its own padding
+
+---
+
+## 5. Embedding Context
+
+### Valid Embedding Locations
+The widget can ONLY be embedded in pages of type:
+- **Tasks (Aktivität):** `ProjektplanungExtendedAppTypes.AKTIVITAET.TYPE`
+- **Milestones (Meilenstein):** `ProjektplanungExtendedAppTypes.MEILENSTEIN.TYPE`
+
+### Validation
+The widget performs strict type checking via:
+```java
+checkIsOneOfTheseTypes(
+    entity,
+    embedding,
+    ProjektplanungExtendedAppTypes.AKTIVITAET.TYPE,
+    ProjektplanungExtendedAppTypes.MEILENSTEIN.TYPE
+)
+```
+
+### Error Messages
+- **Embedding Error:** "Widget should be embedded in a page of type Milestone or Task."
+- **Initialization Error:** "An error occurred on widget initialization."
+- **Load Error:** "An error occurred while loading subscription table."
+
+---
+
+## 6. Relationship to Other Features
+
+### Subscription Feature (Project Planning Extended)
+The widget is tightly integrated with the subscription feature in the "Project Planning (Extended)" app. This feature allows:
+- Subscribing tasks from one schedule to another
+- Creating mirror/copy relationships between planning elements
+- Different subscription modes based on configuration:
+  - Not supported
+  - Only in schedules with write permission
+  - Only in schedules with read or write permission
+
+### Entity Mirror Mechanism
+The widget relies on the platform's `EntityMirror` concept:
+- **EntityMirror:** A platform feature that creates mirror relationships between pages
+- **Mirror Hierarchy:** Subscriptions use `MirrorHierarchyDomain.simple`
+- **Mirror Data:** Stored in `_entityMirrors()` collection on pages
+- **Synchronization:** Subscriptions sync with their original tasks (with some restrictions)
+
+### Related Widgets
+This widget complements other project planning widgets:
+
+1. **Single Gantt Widget** (`cf.projektplanung.singleGantt`)
+   - Shows tasks in Gantt chart format
+   - Subscriptions appear as mirrored tasks in the chart
+
+2. **Multi Gantt Widget** (`cf.projektplanung.multiGantt`)
+   - Shows multiple schedules simultaneously
+   - Subscription relationships visible across schedules
+
+3. **Schedule Tree Widget** (`cf.projektplanung.scheduleTreeTable`)
+   - Displays schedule hierarchy
+   - Shows parent-child relationships
+
+### Configuration Dependencies
+The subscription functionality is controlled by:
+- **App Configuration:** `subscriptionSupport` setting in Plugin Configuration
+- **Subscription Support Values:**
+  - `subscriptionNotSupported`
+  - `subscriptionOnlyInEditableSchedules`
+  - `subscriptionOnlyInReadableSchedules`
+
+---
+
+## 7. Localization
+
+### Supported Languages
+- English (en)
+- German (de)
+
+### Key Messages
+| Message Key | English | German |
+|-------------|---------|--------|
+| name | Subscriptions | Abos |
+| description | Shows the subscriptions of a planning element in a table (only available for the "Task" and "Milestone" types). | Zeigt die Abos eines Planelements in einer Tabelle an (nur verfügbar für die Typen "Vorgang" und "Meilenstein"). |
+| widgetTitle | Subscriptions | Abos |
+| noSubscriptionsExisting | There are no subscriptions | Es existieren keine Abos |
+| totalSubscriptions | Total subscriptions: {0} | Abos insgesamt: {0} |
+| visibleSubscriptions | Visible subscriptions: {0} of {1} | Abos sichtbar: {0} von {1} |
+| visibleSubscriptionsLimitedByWidget | Visible subscriptions: {0} of {1} (limited by widget) | Abos sichtbar: {0} von {1} (von Widget begrenzt) |
+| subscriptionsWithoutReadAccess | Subscriptions without read-access: {0} | Abos ohne Leserecht: {0} |
+
+---
+
+## 8. Performance Considerations
+
+### Optimization Strategies
+
+1. **Limit on Displayed Items**
+   - Maximum 500 subscriptions shown
+   - Prevents performance degradation with large subscription counts
+   - Search query clause limitations
+
+2. **Caching Strategy**
+   - Pre-loads entity mirrors for performance
+   - Uses `Page.SCHEMA.prototype()._entityMirrors().addAssetsToCache()`
+
+3. **Read Access Checking**
+   - Counts total mirrors vs accessible mirrors
+   - Early determination of visibility without loading all data
+
+4. **No Actions Column**
+   - Widget disables the actions column (`showActions() = false`)
+   - Reduces rendering overhead
+
+---
+
+## 9. User Experience
+
+### Visual Feedback
+
+The widget provides clear status information:
+- Shows exact counts of subscriptions
+- Indicates when limit is reached
+- Warns about inaccessible subscriptions
+- Displays helpful error messages
+
+### Empty State
+When no subscriptions exist, shows: "There are no subscriptions"
+
+### Error Handling
+Graceful error display with user-friendly messages instead of stack traces.
+
+### Table Interaction
+- Standard table widget interaction (sorting, filtering via table controls)
+- No in-place editing of subscription data
+- Read-only view of subscription relationships
+
+---
+
+## 10. Testing Evidence
+
+### Test Files Found
+- `TestTaskSubscription.java` - Tests subscription creation and properties
+- `TestSubscriptionChain.java` - Tests subscription hierarchies
+- Various integration tests for subscription functionality
+
+### Key Test Scenarios
+1. Creating subscriptions from tasks
+2. Verifying mirror properties
+3. Testing subscription hierarchies
+4. Validating read-only behavior of mirrored attributes
+
+---
+
+## 11. Historical Context
+
+### Version Information
+- Introduced as part of Project Planning Extended app
+- Deprecated constant since version 25.2 (moved to shared constants)
+- Original constant: `SubscriptionsWidgetDefinition.WIDGET_TYPE_SUBSCRIPTIONS`
+- New location: `SubscriptionsWidgetDefinitionConstants.WIDGET_TYPE_SUBSCRIPTIONS`
+
+### Evolution Notes
+The widget has evolved from simple subscription display to include:
+- Access control awareness
+- Performance optimizations (500 limit)
+- Better user feedback about visibility
+- Integration with new Gantt widgets
+
+---
+
+## Summary
+
+The Subscriptions widget is a specialized, read-only table widget that provides essential visibility into cross-schedule task and milestone references within the cplace project planning system. It serves as a monitoring and transparency tool for users working with multi-schedule projects, helping them understand where their planning elements are being referenced and reused across different project contexts.
+
+**Key Characteristics:**
+- Read-only view of subscriptions
+- Limited to 500 visible items for performance
+- Access-control aware
+- Only embeddable in Task and Milestone pages
+- Minimal configuration (title and height only)
+- Part of the Project Planning (Extended) app ecosystem