@cplace/test-mcp-server 1.0.0 → 1.1.0

package/dist/widget-specifications/cf.platform.singleAttribute/cf.platform.singleColumn.md

@@ -0,0 +1,9 @@
+**Note**: This attribute is only relevant when both `withValue=true` AND `withLabel=true`.
+
+**Layout Modes**:
+- `false` (default): Two-column layout with label and value side by side
+- `true`: Single-column layout with label above value
+
+**Parent Widget Override**: When this widget is embedded inside a `cf.platform.attributesGroup` widget, the parent widget's `singleColumn` setting takes precedence over this widget's setting. The parent's layout configuration will override the individual widget's setting.
+
+**Hidden When Embedded**: This parameter is hidden from the edit UI when the widget is embedded inside `cf.platform.attributesGroup`.

package/dist/widget-specifications/cf.platform.singleAttribute/cf.platform.useParent.md

@@ -0,0 +1,11 @@
+**Purpose**: When enabled, displays an attribute from the parent page of the target entity instead of the target entity itself.
+
+**Valid Values**:
+- `false` (default): Display attribute from the target entity
+- `true`: Display attribute from the target entity's parent page
+
+**Use Case**: Useful for showing parent page attributes in child page layouts, such as displaying project-level information on task detail pages.
+
+**Behavior**: Only takes effect when the target entity is a Page type. If `useParent=true` and the target entity has no parent, the behavior depends on the implementation.
+
+**Note**: This parameter is hidden from the edit UI when the widget is embedded inside `cf.platform.attributesGroup`.

package/dist/widget-specifications/cf.platform.singleAttribute/cf.platform.withLabel.md

@@ -0,0 +1,11 @@
+**Warning**: At least one of `withValue` or `withLabel` must be `true` for the widget configuration to be complete!
+
+**Valid Values**:
+- `false` (default): Hide the attribute's label/name
+- `true`: Show the attribute's localized label/name
+
+**Configuration Completeness Check**: The widget validates that at least one display option is enabled. If both `withValue=false` and `withLabel=false`, the configuration is considered incomplete and the widget will not render properly.
+
+**Note**: The `singleColumn` attribute is only relevant when `withLabel=true` and `withValue=true` - it controls whether the label and value are displayed side by side or stacked vertically.
+
+**Frontend Behavior**: When `withLabel=false` and `inPlaceEditing=false`, the widget renders in inline mode using a span element. Otherwise, it uses a block-level div element.

package/dist/widget-specifications/cf.platform.singleAttribute/cf.platform.withValue.md

@@ -0,0 +1,12 @@
+**Warning**: At least one of `withValue` or `withLabel` must be `true` for the widget configuration to be complete!
+
+**Valid Values**:
+- `true` (default): Show the attribute's value
+- `false`: Hide the attribute's value (only valid if `withLabel=true`)
+
+**Configuration Completeness Check**: The widget validates that at least one display option is enabled. If both `withValue=false` and `withLabel=false`, the configuration is considered incomplete and the widget will not render properly.
+
+**Common Patterns**:
+- `withValue=true, withLabel=false`: Display value only (inline mode)
+- `withValue=true, withLabel=true`: Display both label and value
+- `withValue=false, withLabel=true`: Display label only (useful for showing which attribute is selected without showing its value)

package/dist/widget-specifications/cf.platform.tags/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.tags",
+  "Description": "{\"en\":\"Shows all the tags of a page and allows you to edit them.\",\"de\":\"Zeigt alle Tags einer Seite und erlaubt ihre Bearbeitung.\"}",
+  "Localized Name": "{\"en\":\"Tags\",\"de\":\"Tags\"}",
+  "Icon": "fa-hashtag",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Tags' widget shows all tags added to a cplace page. The tags can be edited.</p>\n\n<p>&nbsp;</p>"
+}

package/dist/widget-specifications/cf.platform.tags/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "metadata",
+    "inline-edit",
+    "searchable",
+    "detail-view",
+    "collaboration"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.tags/_overview.md

@@ -0,0 +1,49 @@
+## Overview
+
+Shows all the tags of a page and allows you to edit them. The Tags widget displays and manages tags on pages. Tags provide a lightweight, flexible categorization system that complements formal data model attributes. Unlike fixed hierarchies or predefined categories, tags allow users to create ad-hoc classifications without modifying the data model.
+
+Every page in the cplace platform can have tags through the built-in `Taggable` mixin. Tags are normalized to lowercase, trimmed of whitespace, and fully integrated with search and versioning.
+
+## Use Cases
+
+- **Content Categorization**: Organize pages with flexible, user-defined labels (e.g., "important", "draft", "q1-2024")
+- **Search and Filtering**: Find pages with specific tags or build tag clouds based on frequency
+- **Workflow and Status Tracking**: Mark pages with workflow states (e.g., "review", "approved", "archived")
+- **Team Collaboration**: Share informal classifications across team members without formal schema changes
+- **Ad-hoc Organization**: Quick categorization for evolving needs without creating formal attributes
+
+## Design Considerations
+
+### When to Use Tags vs. Attributes
+
+Use tags when:
+- Classification needs are fluid and user-driven
+- Multiple cross-cutting categories apply to a single page
+- You want to avoid data model changes
+- Users need to experiment with different organizational schemes
+
+Use formal attributes when:
+- Values must be controlled or validated
+- Classification is part of core business logic
+- Reporting requires consistent, structured data
+
+### Visual Integration
+
+The Tags widget renders without a frame or padding, creating a clean appearance that blends seamlessly into page layouts. The hashtag icon provides instant visual recognition.
+
+### Search Integration
+
+Tags are fully indexed and support:
+- Exact tag matching via filters
+- Prefix-based autocomplete for tag suggestions
+- Tag cloud visualizations based on frequency
+- Space-scoped suggestions for relevance
+
+## Related Patterns
+
+- **cf.platform.attributes** - Display page attributes (formal structured data)
+- **cf.platform.modificationInfo** - Show creation/modification metadata
+- **cf.platform.incomingLinks** - Display references to a page
+- **cf.platform.comments** - Show page comments
+
+These widgets often appear together on page views to provide comprehensive metadata visualization.

package/dist/widget-specifications/cf.platform.tags/_summary.md

@@ -0,0 +1 @@
+Shows all the tags of a page and allows you to edit them. Enables flexible categorization and classification of pages for better organization and searchability.

package/dist/widget-specifications/cf.platform.wiki/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.platform.wiki",
+  "Description": "{\"en\":\"Adds a wiki to the page.\",\"de\":\"Fügt ein Wiki zur Seite hinzu.\"}",
+  "Localized Name": "{\"en\":\"Wiki\",\"de\":\"Wiki\"}",
+  "Icon": "fa-wikipedia-w",
+  "Plugin": "cf.cplace.platform",
+  "App": "cf.cplace.platform",
+  "Localized App Name": "{\"en\":\"cplace Basis\",\"de\":\"cplace Basis\"}",
+  "Repository": "cplace",
+  "* Details DE": null,
+  "* Details EN": "<p><strong>More Details</strong></p>\n\n<p>The 'Wiki' widget adds a fully-fledged Wiki editor component to a cplace page.</p>"
+}

package/dist/widget-specifications/cf.platform.wiki/_meta.json

@@ -0,0 +1,9 @@
+{
+  "tags": [
+    "rich-text",
+    "collaboration",
+    "inline-edit",
+    "detail-view"
+  ],
+  "requiredApp": null
+}

package/dist/widget-specifications/cf.platform.wiki/_overview.md

@@ -0,0 +1,32 @@
+## Overview
+
+Adds a wiki to the page. The Wiki widget provides a Wikipedia-style rich-text editing experience for the built-in content field of pages, documents, and principal entities. It renders and allows in-place editing of HTML-formatted content including text, links, images, and embedded widgets.
+
+Unlike the Custom Rich String Attribute widget which works with custom attributes, the Wiki widget is specifically designed for the system's built-in content/description fields and requires no configuration.
+
+## Use Cases
+
+- **Page content management**: Create documentation pages, knowledge bases, project descriptions, and meeting notes with collaborative wiki-style editing
+- **Document descriptions**: Add contextual descriptions and explanations to uploaded files
+- **User profiles and group descriptions**: Create rich bio information, team descriptions, and document roles and responsibilities
+- **Type definition documentation**: Document custom types with usage guidelines and examples
+
+## Design Considerations
+
+### Zero Configuration
+The widget has no configurable attributes. It automatically determines which content field to use based on the entity type:
+- Pages and Documents: Uses the `_content()` field
+- Persons and Groups: Uses the `_description()` field
+- Type Definitions: Uses the `_description()` field
+
+### Single Instance Per Entity
+Only one Wiki widget should be embedded per entity since each entity has only one built-in content/description field.
+
+### In-Place Editing
+The widget provides modal-free, in-place editing rather than opening a separate dialog, making for a seamless content editing experience.
+
+## Related Patterns
+
+- **Custom Rich String Attribute Widget** (`cf.platform.customRichStringAttribute`): Use when you need to display/edit a custom rich-text attribute rather than the built-in content field. Offers configuration options like frame visibility and attribute selection.
+- **Attributes Widget**: Displays all entity attributes in a form layout
+- **Single Attribute Widget** (`cf.platform.singleAttribute`): Displays a single attribute value

package/dist/widget-specifications/cf.platform.wiki/_summary.md

@@ -0,0 +1 @@
+Adds a wiki to the page. Displays and enables in-place editing of the built-in rich-text content field for pages, documents, and user profiles with zero configuration.

package/dist/widget-specifications/cf.projektplanung.gantt/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.gantt",
+  "Description": "{\"en\":\"Provides the \\\"New Gantt\\\" widget, which enables the visualization and editing of planning elements and hybrid elements.\",\"de\":\"Stellt das Widget “Neues Gantt” bereit, welches das Visualisieren und Editieren von Planungselementen und hybriden Elementen ermöglicht.\"}",
+  "Localized Name": "{\"en\":\"New Gantt\",\"de\":\"Neues Gantt\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projectPlanning",
+  "App": "cf.cplace.projectPlanning.app.gantt2.gantt2",
+  "Localized App Name": "{\"en\":\"New Gantt\",\"de\":\"Neues Gantt\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.gantt/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "timeline",
+    "scheduling",
+    "tree",
+    "drag-drop",
+    "inline-edit",
+    "connected"
+  ],
+  "requiredApp": "cf.cplace.projectPlanning.app.gantt2.gantt2"
+}

package/dist/widget-specifications/cf.projektplanung.gantt/_overview.md

@@ -0,0 +1,61 @@
+## Overview
+
+The New Gantt widget enables the visualization and editing of planning elements and hybrid elements. Built on the Bryntum Gantt framework, it displays tasks as horizontal bars on a timeline, showing start dates, end dates, duration, and progress. The widget supports hierarchical task structures with expandable/collapsible tree views and allows users to manage dependencies between tasks.
+
+Key capabilities include:
+- **Visual timeline representation** of tasks with bars showing duration and progress
+- **Interactive editing** through drag-and-drop repositioning and bar resizing
+- **Dependency management** for creating and visualizing task relationships
+- **Hierarchical structure** with parent-child task relationships
+- **Multi-schedule support** for displaying tasks from one or multiple schedules
+- **Real-time synchronization** between the chart and cplace backend
+- **Hybrid element support** for tasks referenced from external systems
+
+## Use Cases
+
+### Project Planning Visualization
+Display the entire project timeline at a glance to understand task sequences, identify critical paths and bottlenecks, and monitor progress through percent completion indicators.
+
+### Interactive Schedule Management
+Adjust task dates by dragging bars, modify durations by resizing, create predecessor/successor relationships, and update task properties inline without leaving the chart view.
+
+### Multi-Schedule Planning
+Consolidate and compare timelines across different projects or work packages by displaying tasks from multiple schedules in a single unified view for portfolio-level planning.
+
+### Hybrid Element Planning
+Work with both native planning elements and hybrid elements that reference tasks from other systems, including delegated tasks sourced from external schedules and mirrored tasks that reflect changes from source tasks.
+
+## Design Considerations
+
+### When to Use
+- Users need a graphical timeline view rather than a table/list view
+- Visual planning and scheduling is important for understanding the project
+- Users need to interactively adjust dates through drag-and-drop
+- Understanding task relationships and dependencies is critical
+- Working with complex project hierarchies that benefit from tree + timeline views
+- Real-time collaboration on schedule adjustments is needed
+
+### When to Consider Alternatives
+- Users only need a simple task list without timeline visualization (use Schedule Tree Widget)
+- Primary focus is on data entry and bulk editing (table views may be more efficient)
+- Detailed attribute editing is the main activity (use detail pages or forms)
+- Very large datasets (1000+ tasks) may require filtering for performance
+
+### Configuration Options
+- **Schedule Selection**: Either explicitly specify schedules via the SCHEDULE attribute, or automatically load from the embedding page (SCHEDULE_SELECTION attribute)
+- **Widget Title**: Custom title for display (defaults to "Gantt chart for the schedules {names}")
+- **Height**: Fixed height setting for vertical space allocation
+- **Root Node Configuration**: Specify which nodes should appear as root elements in the hierarchy
+
+### Embedding Restrictions
+- Only one Gantt widget instance allowed per page
+- Requires the Gantt2 feature to be enabled
+- Cannot be configured directly in view mode
+
+## Related Patterns/Alternatives
+
+| Widget | When to Use Instead |
+|--------|---------------------|
+| **Schedule Tree Widget** (`cf.projektplanung.scheduleTreeTable`) | For table-based schedule views without timeline visualization; better suited for data-heavy operations and bulk editing. Often used alongside the Gantt on the same page. |
+| **Schedule Lock State Widget** (`cf.projektplanung.scheduleLockState`) | Used alongside Gantt to show lock state of schedules and prevent concurrent editing conflicts |
+| **Single Gantt Widget** (`cf.projektplanung.singleGantt`) | For simpler single-schedule Gantt views |

package/dist/widget-specifications/cf.projektplanung.gantt/_summary.md

@@ -0,0 +1 @@
+Enables the visualization and editing of planning elements and hybrid elements in an interactive Gantt chart. Built on the Bryntum Gantt framework, it supports drag-and-drop scheduling, dependency management, hierarchical task structures, and real-time synchronization with the cplace backend.

package/dist/widget-specifications/cf.projektplanung.ganttTaskDemo/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.ganttTaskDemo",
+  "Description": "{\"en\":\"Shows a preview of the task class.\",\"de\":\"Zeigt eine Vorschau der Vorgangsklasse.\"}",
+  "Localized Name": "{\"en\":\"Task Class Preview\",\"de\":\"Vorgangsklassen-Vorschau\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanungMasterData",
+  "App": "cf.cplace.projektplanungMasterData",
+  "Localized App Name": "{\"en\":\"Task Classes\",\"de\":\"Vorgangsklassen\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.ganttTaskDemo/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "timeline",
+    "read-only",
+    "detail-view",
+    "scheduling",
+    "media"
+  ],
+  "requiredApp": "cf.cplace.projektplanungMasterData"
+}

package/dist/widget-specifications/cf.projektplanung.ganttTaskDemo/_overview.md

@@ -0,0 +1,65 @@
+## Overview
+
+The Task Class Preview widget shows a preview of the task class. It serves as a configuration assistant for Task Classes (Activity Classes) in the cplace project planning module, providing immediate visual feedback as administrators configure visual properties, showing how tasks and milestones of that class will appear in actual Gantt charts.
+
+The widget displays four preview variants simultaneously:
+- **Activity**: Regular task bar appearance
+- **Milestone**: Point-in-time marker appearance
+- **Rollup Activity**: Collapsed summary bar appearance
+- **Rollup Milestone**: Collapsed milestone indicator appearance
+
+## Use Cases
+
+### Primary Use Case: Task Class Configuration
+
+Users don't explicitly "choose" this widget - it's automatically included in the default layout of every Task Class page. It is useful when:
+
+1. **Creating New Task Classes**: Setting up visual distinctions for different types of tasks (e.g., "Development", "Testing", "Review"), choosing colors, and selecting shapes that intuitively represent task characteristics.
+
+2. **Customizing Existing Task Classes**: Adjusting colors for better contrast or accessibility, changing bar patterns to distinguish similar task types, configuring rollup appearance for hierarchical project views.
+
+3. **Visual Consistency Verification**: Ensuring that task visual styles are consistent across the organization, previewing how tasks will appear before applying changes.
+
+### Problem It Solves
+
+Without this widget, administrators would have to configure Task Class properties blindly, save changes, navigate to a Gantt chart, find a task with that class, evaluate the appearance, navigate back to make adjustments, and repeat the cycle. The preview widget eliminates this cycle by providing immediate WYSIWYG feedback.
+
+## Design Considerations
+
+### Embedding Context
+
+This widget can only be embedded on pages of type `cf.activityClass` (Task Class). It reads all custom attributes from the embedding Task Class page and renders the preview accordingly.
+
+### No Configuration Required
+
+The widget itself has no configuration options - it's a pure preview/display widget. It visualizes the Task Class attributes:
+- Shape selections (activity and milestone shapes)
+- Colors (bar color, border color)
+- Patterns (stripes, dots, solid fill)
+- Rollup colors (optional fallback to main colors)
+- Label positions
+
+### Live Updates
+
+Changes to any Task Class attribute trigger immediate re-rendering of the preview. The widget uses SVG-based rendering for scalable, crisp shapes.
+
+## Related Patterns
+
+### Part of Project Planning Master Data
+
+This widget is part of the Master Data configuration layer that supports the visualization layer:
+
+- **Task Classes** define how tasks look
+- **Gantt Chart Widgets** (`cf.projektplanung.gantt`, `cf.projektplanung.multiGantt`, `cf.projektplanung.singleGantt`) consume Task Class styling
+- **Schedule Tree Widget** also uses Task Class styling for visual indicators
+
+### Typical Page Layout
+
+On Task Class pages, the default layout typically places:
+- Attributes widget (left, 8-width) for editing properties
+- This preview widget (right, 4-width) for visual feedback
+- Wiki widget below for documentation
+
+## Alternatives
+
+There is no alternative widget for previewing Task Class styling. The preview functionality is unique to this widget.

package/dist/widget-specifications/cf.projektplanung.ganttTaskDemo/_summary.md

@@ -0,0 +1 @@
+Shows a preview of the task class, providing a live visual preview of how tasks and milestones will appear in Gantt charts based on their configured styling properties. Use when configuring Task Classes to see real-time feedback on colors, shapes, patterns, and label positions.

package/dist/widget-specifications/cf.projektplanung.multiGantt/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.multiGantt",
+  "Description": "{\"en\":\"Displays any number of schedules at the same time, which are pre-selected in the widget configuration.\",\"de\":\"Zeigt beliebig viele Pläne gleichzeitig an, die per Vorauswahl in der Widget-Konfiguration festgelegt werden.\"}",
+  "Localized Name": "{\"en\":\"Multi Gantt Chart\",\"de\":\"Multi-Gantt-Diagramm\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanung",
+  "App": "cf.cplace.projektplanung.projektplanungBasic",
+  "Localized App Name": "{\"en\":\"Project Planning (Basic)\",\"de\":\"Projektplanung (Basis)\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.multiGantt/_meta.json

@@ -0,0 +1,11 @@
+{
+  "tags": [
+    "timeline",
+    "tree",
+    "time-series",
+    "scheduling",
+    "dashboard",
+    "connected"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}

package/dist/widget-specifications/cf.projektplanung.multiGantt/_overview.md

@@ -0,0 +1,73 @@
+## Overview
+
+The Multi Gantt Chart widget displays any number of schedules at the same time, which are pre-selected in the widget configuration. It aggregates multiple schedules into a unified timeline visualization, enabling stakeholders to see consolidated project timelines at a glance.
+
+**Use when**:
+- Building project dashboards that need to show all associated schedules
+- Creating portfolio-level views across multiple projects or programs
+- Providing executive summaries of timeline status across organizational units
+
+**Alternatives**:
+- **Single Gantt Link**: When you only need to preview a single schedule
+- **Schedule Tree Table**: When tabular WBS data is more appropriate than timeline visualization
+
+## Use Cases
+
+### Project Timeline Dashboard
+A project manager needs visibility into all schedules related to their project. The Multi-Gantt consolidates schedules that are either direct children of the project or linked through additional associations, presenting them in one interactive timeline.
+
+### Portfolio Overview
+Program managers and executives need to monitor multiple projects simultaneously. The widget can aggregate schedules across a filtered set of projects, enabling cross-project timeline comparison and dependency awareness.
+
+### Status Reporting Views
+For stakeholder communication, a read-only aggregated view provides timeline context without the risk of accidental modifications. This supports status meetings and reporting workflows where visibility matters more than editability.
+
+## Behavior and Capabilities
+
+### Schedule Aggregation
+The widget discovers schedules through search-based filtering. This allows flexible aggregation strategies:
+- Schedules directly owned by a project
+- Schedules linked through reference attributes
+- Schedules matching arbitrary search criteria
+
+The dual-path discovery pattern (parent reference OR link reference) is common, ensuring schedules are found regardless of how they relate to the containing page.
+
+### Expansion Control
+Users can control how much detail appears initially. The widget supports starting fully expanded (all tasks visible), partially expanded (schedule headers visible, tasks hidden), or fully collapsed (compact summary). This lets designers balance information density against cognitive load.
+
+### Read-Only Mode
+The widget can operate in read-only mode, preventing inline edits while preserving visualization and navigation capabilities. This is essential for aggregation views where editing should happen at the individual schedule level.
+
+### Cross-Schedule Dependencies
+Dependency relationships between schedules can be shown or hidden. Showing dependencies reveals cross-schedule coordination requirements; hiding them reduces visual complexity for overview purposes.
+
+### Sorting
+Schedules can be ordered by various attributes, most commonly by name for intuitive alphabetical navigation.
+
+## Design Considerations
+
+### Information Density Trade-offs
+Aggregating many schedules creates information overload risk. Design decisions to mitigate this:
+- Start collapsed to give users control over what they expand
+- Hide cross-links in overview contexts to reduce visual noise
+- Use read-only mode to signal "viewing" rather than "editing" intent
+
+### Editing Context
+Multi-Gantt is fundamentally an aggregation view. While it can support editing, the recommended pattern is to use it for overview and navigation, directing users to individual schedule views for detailed editing. This prevents confusion about which schedule they're modifying.
+
+### Performance Awareness
+Large aggregations (many schedules with many tasks) can impact performance. For portfolio-level views spanning many projects, consider filtering strategies or pagination approaches to keep the visualization responsive.
+
+### Search Filter Design
+The search mechanism is powerful but requires careful filter construction. The common pattern of searching for schedules via multiple reference paths (parent AND link) provides flexibility but adds complexity. Test filter logic thoroughly before deployment.
+
+## Related Widgets
+
+### Single Gantt Link
+**Single Gantt Link** provides a lightweight preview of a single schedule. Use it when embedding schedule context without the full multi-schedule aggregation overhead. It's a simpler choice when only one schedule is relevant.
+
+### Schedule Tree Table
+**Schedule Tree Table** presents WBS (Work Breakdown Structure) data in tabular form rather than timeline form. Choose it when users need to see task details, assignments, or other attributes that don't fit well in a Gantt visualization.
+
+### Complementary Pattern
+A common layout pattern places Multi-Gantt on a dedicated "Timeline" or "Gantt" tab, keeping the main page cleaner while providing focused timeline access. This separates timeline visualization from other project information widgets.

package/dist/widget-specifications/cf.projektplanung.multiGantt/_summary.md

@@ -0,0 +1 @@
+Displays any number of schedules at the same time, which are pre-selected in the widget configuration. Use for project dashboards, portfolio views, or executive summaries showing consolidated timelines across multiple schedules.

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.scheduleTreeTable",
+  "Description": "{\"en\":\"Shows tasks and milestones of one or more schedules in a tree table.\",\"de\":\"Zeigt Vorgänge und Meilensteine eines oder mehrerer Pläne in einer Strukturtabelle an.\"}",
+  "Localized Name": "{\"en\":\"Structured Table for Schedules\",\"de\":\"Strukturtabelle für Pläne\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanung",
+  "App": "cf.cplace.projektplanung.projektplanungBasic",
+  "Localized App Name": "{\"en\":\"Project Planning (Basic)\",\"de\":\"Projektplanung (Basis)\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_meta.json

@@ -0,0 +1,10 @@
+{
+  "tags": [
+    "table",
+    "tree",
+    "time-series",
+    "scheduling",
+    "inline-edit"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_overview.md

@@ -0,0 +1,84 @@
+## Overview
+
+The Structured Table for Schedules widget shows tasks and milestones of one or more schedules in a tree table. It displays a schedule's work breakdown structure (WBS) as an interactive, hierarchical table, providing a spreadsheet-like interface where users can view and edit task properties while navigating through the project hierarchy using expand/collapse controls.
+
+**Use when**: Users need to work with task data in a structured, tabular format. This is ideal for data-centric editing tasks such as updating dates, durations, progress percentages, and assignments across multiple tasks. The familiar spreadsheet paradigm makes it accessible to users who prefer working with rows and columns over visual timelines.
+
+**Alternatives**:
+- **Single Gantt Link**: When timeline visualization and dependency relationships are more important than tabular editing
+- **Embedded Search as Table**: When displaying a flat list of tasks without hierarchical structure
+- **Multi-Gantt**: When aggregating tasks across multiple schedules in a timeline view
+
+## Use Cases
+
+### Project Managers Updating Task Details
+A project manager needs to update start dates, end dates, and progress percentages for multiple tasks. The tabular format allows rapid data entry, similar to working in a spreadsheet, without needing to open each task individually.
+
+### Work Breakdown Structure Review
+During planning sessions, teams review the complete task hierarchy to ensure nothing is missing. The expandable tree structure lets them drill down into specific areas while maintaining context of the overall project structure.
+
+### Status Reporting and Progress Tracking
+Managers review task completion status across the project. The tabular view provides a quick scan of progress percentages and status indicators, making it easy to identify tasks that are behind schedule.
+
+### Resource Assignment
+When assigning team members to tasks, the table format allows users to see all assignments at once and make bulk updates to the responsible person column.
+
+## Behavior and Capabilities
+
+### Hierarchical Navigation
+The widget presents tasks in a tree structure that mirrors the project's work breakdown structure. Parent tasks can be expanded to reveal child tasks, and the entire hierarchy can be navigated through expand/collapse controls. This preserves the logical grouping of work while allowing users to focus on specific areas.
+
+### Inline Editing
+Unlike read-only table views, the Schedule Tree Table supports direct editing of task properties within the table cells. Users can modify values without navigating away from the overview, enabling efficient bulk updates.
+
+### Schedule Context Awareness
+The widget understands its context within cplace. It can automatically display tasks from the schedule page it's embedded in, or it can be configured to find schedules through search criteria or reference attributes. This flexibility allows the same widget to serve different architectural patterns.
+
+### Automatic Column Selection
+Standard schedule-relevant columns are included automatically, covering the essential task properties: names, dates, durations, progress, status indicators, and assignments. This reduces configuration overhead while ensuring users see the information they need.
+
+## Design Considerations
+
+### When to Choose Tree Table Over Gantt
+The Tree Table and Gantt views represent complementary perspectives on the same data:
+
+- **Choose Tree Table** when users primarily need to edit data values, perform bulk updates, or review detailed properties across many tasks. The tabular format excels at data manipulation.
+
+- **Choose Gantt** when users need to understand temporal relationships, visualize dependencies, or see how tasks fit together on a timeline. The visual format excels at schedule comprehension.
+
+Many solutions offer both views, allowing users to switch based on their current task.
+
+### Height and Scrolling Trade-offs
+Fixed height widgets create predictable layouts but require scrolling for large schedules. Consider the typical schedule size in your solution:
+- Smaller heights keep the widget compact but require more scrolling
+- Larger heights show more tasks at once but consume more screen space
+- Very large schedules may benefit from pagination or filtering strategies
+
+### Placement in Layout Architecture
+The Tree Table works well as a dedicated view within a tabbed layout. This separates the data-editing interface from other schedule views, letting users consciously choose their working mode. Placing it alongside a Gantt view on the same page can create visual competition and cognitive overload.
+
+### Performance with Large Hierarchies
+Deeply nested or very wide hierarchies may affect rendering performance. For schedules with hundreds of tasks, consider whether users actually need to see the entire structure at once, or whether filtering and drill-down patterns would serve them better.
+
+### Permission Boundaries
+Inline editing requires write permissions on the underlying tasks. The widget gracefully handles read-only access by displaying data without edit controls, but designers should consider whether users on a particular layout will have the necessary permissions.
+
+## Related Widgets
+
+### Single Gantt Link
+A timeline-focused view of the same schedule data. While the Tree Table emphasizes data manipulation, the Gantt emphasizes visual scheduling. They complement each other and are often offered as alternative views of the same schedule.
+
+### Multi-Gantt
+Aggregates tasks from multiple schedules into a single timeline view. Where the Tree Table focuses on one schedule's detailed structure, the Multi-Gantt provides cross-project visibility. They serve different analytical needs.
+
+### Embedded Search as Table
+A general-purpose table widget that can display any search results. Unlike the Tree Table, it doesn't understand hierarchical relationships or provide the specialized schedule-aware features. Use it when you need a flat task list without WBS navigation.
+
+### Layout Tabs Widget
+Often used as a container to offer users a choice between Tree Table and Gantt views. The fixed-height nature of the Tree Table works well within tabbed layouts where content area consistency matters.
+
+## Data Model Context
+
+The Schedule Tree Table operates on the cplace scheduling data model. It displays Activities and Milestones that belong to a Schedule, automatically traversing the parent-child relationships to build the tree structure. The widget understands how tasks nest within each other and represents this hierarchy through indentation and expand/collapse controls.
+
+This tight integration with the scheduling data model means the widget requires the Project Planning plugin (cf.projektplanung namespace) and must have access to a valid schedule context to function.

package/dist/widget-specifications/cf.projektplanung.scheduleTreeTable/_summary.md

@@ -0,0 +1 @@
+Shows tasks and milestones of one or more schedules in a tree table. Use when users need spreadsheet-like editing of task properties (dates, progress, assignments) while navigating the project hierarchy.

package/dist/widget-specifications/cf.projektplanung.singleGantt/_catalog-data.json

@@ -0,0 +1,12 @@
+{
+  "Widget": "cf.projektplanung.singleGantt",
+  "Description": "{\"en\":\"Gantt chart of all tasks and milestones of this schedule.\",\"de\":\"Gantt-Diagramm aller Vorgänge und Meilensteine dieses Plans.\"}",
+  "Localized Name": "{\"en\":\"Gantt chart\",\"de\":\"Gantt-Diagramm\"}",
+  "Icon": "cf-widget",
+  "Plugin": "cf.cplace.projektplanung",
+  "App": "cf.cplace.projektplanung.projektplanungBasic",
+  "Localized App Name": "{\"en\":\"Project Planning (Basic)\",\"de\":\"Projektplanung (Basis)\"}",
+  "Repository": "cplace-project-planning",
+  "* Details DE": null,
+  "* Details EN": null
+}

package/dist/widget-specifications/cf.projektplanung.singleGantt/_meta.json

@@ -0,0 +1,12 @@
+{
+  "tags": [
+    "timeline",
+    "chart",
+    "scheduling",
+    "tree",
+    "inline-edit",
+    "read-only",
+    "connected"
+  ],
+  "requiredApp": "cf.cplace.projektplanung.projektplanungBasic"
+}