@acorex-platform/module-software-management-client 0.0.46

package/fesm2022/acorex-platform-module-software-management-client-contracts.mjs

@@ -0,0 +1,1196 @@
+/**
+ * Applications & Platform capability for defining standalone software products.
+ * Group ids live in `AXPCommonPermissionGroupKeys`.
+ */
+const AXPSoftwareManagementPermissionKeys = {
+    MaintainSoftwareDefinitions: 'ApplicationsPlatform:Permission:MaintainSoftwareDefinitions',
+};
+
+const AXPSoftwareManagementMenuKeys = {
+    Root: 'SoftwareManagement:Menu',
+    Software: 'SoftwareManagement:Menu:Software',
+    DiscoveryItems: 'SoftwareManagement:Menu:DiscoveryItems',
+    ScopeItems: 'SoftwareManagement:Menu:ScopeItems',
+    Requirements: 'SoftwareManagement:Menu:Requirements',
+    AcceptanceCriteria: 'SoftwareManagement:Menu:AcceptanceCriteria',
+    BusinessRules: 'SoftwareManagement:Menu:BusinessRules',
+    Modules: 'SoftwareManagement:Menu:Modules',
+    Features: 'SoftwareManagement:Menu:Features',
+    UseCases: 'SoftwareManagement:Menu:UseCases',
+    DesignDecisions: 'SoftwareManagement:Menu:DesignDecisions',
+};
+
+const config = {
+    i18n: 'software-management',
+    module: 'SoftwareManagement',
+};
+const RootConfig = {
+    config,
+    module: {
+        module: 'software-management',
+        name: config.module,
+        title: `@${config.i18n}:module.title`,
+        icon: 'fa-light fa-diagram-project',
+    },
+    entities: {
+        software: {
+            name: 'Software',
+            source: `${config.module}.Software`,
+            title: `@${config.i18n}:entities.software.title`,
+            titlePlural: `@${config.i18n}:entities.software.plural`,
+            icon: 'fa-light fa-lightbulb',
+        },
+        discoveryItem: {
+            name: 'SoftwareDiscoveryItem',
+            source: `${config.module}.SoftwareDiscoveryItem`,
+            title: `@${config.i18n}:entities.discovery-item.title`,
+            titlePlural: `@${config.i18n}:entities.discovery-item.plural`,
+            icon: 'fa-light fa-magnifying-glass',
+        },
+        scopeItem: {
+            name: 'SoftwareScopeItem',
+            source: `${config.module}.SoftwareScopeItem`,
+            title: `@${config.i18n}:entities.scope-item.title`,
+            titlePlural: `@${config.i18n}:entities.scope-item.plural`,
+            icon: 'fa-light fa-border-outer',
+        },
+        requirement: {
+            name: 'SoftwareRequirement',
+            source: `${config.module}.SoftwareRequirement`,
+            title: `@${config.i18n}:entities.requirement.title`,
+            titlePlural: `@${config.i18n}:entities.requirement.plural`,
+            icon: 'fa-light fa-list-check',
+        },
+        acceptanceCriterion: {
+            name: 'SoftwareAcceptanceCriterion',
+            source: `${config.module}.SoftwareAcceptanceCriterion`,
+            title: `@${config.i18n}:entities.acceptance-criterion.title`,
+            titlePlural: `@${config.i18n}:entities.acceptance-criterion.plural`,
+            icon: 'fa-light fa-badge-check',
+        },
+        businessRule: {
+            name: 'SoftwareBusinessRule',
+            source: `${config.module}.SoftwareBusinessRule`,
+            title: `@${config.i18n}:entities.business-rule.title`,
+            titlePlural: `@${config.i18n}:entities.business-rule.plural`,
+            icon: 'fa-light fa-scale-balanced',
+        },
+        module: {
+            name: 'SoftwareModule',
+            source: `${config.module}.SoftwareModule`,
+            title: `@${config.i18n}:entities.module.title`,
+            titlePlural: `@${config.i18n}:entities.module.plural`,
+            icon: 'fa-light fa-cubes',
+        },
+        feature: {
+            name: 'SoftwareFeature',
+            source: `${config.module}.SoftwareFeature`,
+            title: `@${config.i18n}:entities.feature.title`,
+            titlePlural: `@${config.i18n}:entities.feature.plural`,
+            icon: 'fa-light fa-puzzle-piece',
+        },
+        useCase: {
+            name: 'SoftwareUseCase',
+            source: `${config.module}.SoftwareUseCase`,
+            title: `@${config.i18n}:entities.use-case.title`,
+            titlePlural: `@${config.i18n}:entities.use-case.plural`,
+            icon: 'fa-light fa-person-walking-arrow-right',
+        },
+        designDecision: {
+            name: 'SoftwareDesignDecision',
+            source: `${config.module}.SoftwareDesignDecision`,
+            title: `@${config.i18n}:entities.design-decision.title`,
+            titlePlural: `@${config.i18n}:entities.design-decision.plural`,
+            icon: 'fa-light fa-compass-drafting',
+        },
+    },
+};
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Manifest ----
+const SoftwareManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'platform',
+    domain: 'platform',
+    required: false,
+};
+//#endregion
+
+const AXPSoftwareManagementCommandKeys = {
+    Software: {
+        StartFlow: 'SoftwareManagement.Software:StartFlow',
+        CompletePhase: 'SoftwareManagement.Software:CompletePhase',
+        AcceptSuggestion: 'SoftwareManagement:AcceptSuggestion',
+        GenerateKickoffSheet: 'SoftwareManagement.Software:GenerateKickoffSheet',
+        SubmitKickoffSheet: 'SoftwareManagement.Software:SubmitKickoffSheet',
+        ExportKickoffPdf: 'SoftwareManagement.Software:ExportKickoffPdf',
+        OpenKickoffSheet: 'SoftwareManagement.Software:OpenKickoffSheet',
+        ViewPinnedKickoff: 'SoftwareManagement.Software:ViewPinnedKickoff',
+        GenerateDiscoveryReport: 'SoftwareManagement.Software:GenerateDiscoveryReport',
+        SubmitDiscoveryReport: 'SoftwareManagement.Software:SubmitDiscoveryReport',
+        ExportDiscoveryReportPdf: 'SoftwareManagement.Software:ExportDiscoveryReportPdf',
+        OpenDiscoveryReport: 'SoftwareManagement.Software:OpenDiscoveryReport',
+        LinkDiscoveryQuestionnaire: 'SoftwareManagement.Software:LinkDiscoveryQuestionnaire',
+    },
+    WorkflowActivity: {
+        CompletePhase: 'workflow-activity:complete-software-phase',
+        LoadIntroduction: 'workflow-activity:load-software-introduction',
+        SaveIntroduction: 'workflow-activity:save-software-introduction',
+    },
+};
+
+const SOFTWARE_PHASES = [
+    'introduction',
+    'discovery',
+    'first-version-scope',
+    'behavior-specification',
+    'design',
+    'delivery-planning',
+];
+const SOFTWARE_DEFINITION_WORKFLOW_NAME = 'software-definition';
+function softwarePhaseIndex(phase) {
+    return SOFTWARE_PHASES.indexOf(phase);
+}
+function nextSoftwarePhase(phase) {
+    const index = softwarePhaseIndex(phase);
+    if (index < 0 || index >= SOFTWARE_PHASES.length - 1) {
+        return null;
+    }
+    return SOFTWARE_PHASES[index + 1];
+}
+function isSoftwarePhaseAtLeast(current, required) {
+    const currentIndex = softwarePhaseIndex(current);
+    const requiredIndex = softwarePhaseIndex(required);
+    return currentIndex >= 0 && requiredIndex >= 0 && currentIndex >= requiredIndex;
+}
+
+const SOFTWARE_ORIGINS = ['original', 'assumption', 'suggestion', 'approved-fact'];
+const SOFTWARE_PROPOSED_BY = ['user', 'ai'];
+const SOFTWARE_DISCOVERY_KINDS = [
+    'audience',
+    'problem',
+    'pain',
+    'current-practice',
+    'constraint',
+    'alternative',
+    'hypothesis',
+    'evidence',
+    'unknown',
+];
+const SOFTWARE_SCOPE_KINDS = ['capability', 'out-of-scope', 'success-metric'];
+const SOFTWARE_DESIGN_KINDS = ['data-model', 'ux', 'technical'];
+
+const M = (en, fa) => ({ 'en-US': en, 'fa-IR': fa });
+const completeAction = {
+    name: 'complete-phase',
+    title: '@software-management:actions.complete-phase.title',
+    icon: 'fa-light fa-check',
+    color: 'success',
+    command: { name: 'complete-phase' },
+};
+const dialogCancelAction = {
+    title: '@general:actions.cancel.title',
+    icon: 'fa-times',
+    color: 'default',
+    command: { name: 'cancel' },
+};
+const dialogSaveAction = {
+    title: '@general:actions.save.title',
+    icon: 'fa-check',
+    color: 'primary',
+    command: { name: 'submit', options: { validate: true } },
+};
+function introductionField(label, path, editor, readonly) {
+    const editorNode = editor === 'lookup-editor'
+        ? {
+            type: 'lookup-editor',
+            path,
+            name: path,
+            options: {
+                entity: 'SecurityManagement.User',
+                textField: 'displayName',
+                valueField: 'id',
+                look: 'select',
+                columns: ['displayName', 'username'],
+                readonly,
+                disabled: readonly,
+            },
+        }
+        : {
+            type: editor,
+            path,
+            name: path,
+            options: {
+                readonly,
+                disabled: readonly,
+                ...(editor === 'large-text-editor' ? { rows: 4 } : {}),
+            },
+        };
+    return {
+        type: 'grid-item-layout',
+        options: { colSpan: 12 },
+        children: [
+            {
+                type: 'form-field',
+                options: { label, showLabel: true },
+                children: [editorNode],
+            },
+        ],
+    };
+}
+function introductionDialogLayout(readonly) {
+    return {
+        type: 'grid-layout',
+        mode: readonly ? 'view' : 'edit',
+        options: {
+            grid: {
+                default: {
+                    columns: 'repeat(12, 1fr)',
+                    rows: 'repeat(7, auto)',
+                    gap: '16px',
+                },
+            },
+        },
+        children: [
+            introductionField('@software-management:entities.software.fields.title.title', 'title', 'text-editor', readonly),
+            introductionField('@software-management:entities.software.fields.idea.title', 'idea', 'large-text-editor', readonly),
+            introductionField('@software-management:entities.software.fields.initial-problem.title', 'initialProblem', 'large-text-editor', readonly),
+            introductionField('@software-management:entities.software.fields.goal.title', 'goal', 'large-text-editor', readonly),
+            introductionField('@software-management:entities.software.fields.owner.title', 'ownerId', 'lookup-editor', readonly),
+            introductionField('@software-management:entities.software.fields.potential-users.title', 'potentialUsers', 'large-text-editor', readonly),
+            introductionField('@software-management:entities.software.fields.open-questions.title', 'openQuestions', 'large-text-editor', readonly),
+        ],
+    };
+}
+function introductionDialogContext() {
+    return {
+        title: '{{ context.eval("outputs.last.title") }}',
+        idea: '{{ context.eval("outputs.last.idea") }}',
+        initialProblem: '{{ context.eval("outputs.last.initialProblem") }}',
+        goal: '{{ context.eval("outputs.last.goal") }}',
+        ownerId: '{{ context.eval("outputs.last.ownerId") }}',
+        potentialUsers: '{{ context.eval("outputs.last.potentialUsers") }}',
+        openQuestions: '{{ context.eval("outputs.last.openQuestions") }}',
+    };
+}
+function phaseTask(id, phase, title, description) {
+    return {
+        id,
+        name: 'workflow-activity:human-task',
+        title,
+        inputs: {
+            title: `{{ inputs.softwareTitle }} — ${title}`,
+            description,
+            assignedUserIds: '{{ inputs.ownerId }}',
+            context: {
+                softwareId: '{{ inputs.softwareId }}',
+                phase,
+                entityType: 'SoftwareManagement.Software',
+            },
+            actions: { suffix: [completeAction] },
+        },
+    };
+}
+function completePhaseActivity(id, phase) {
+    return {
+        id,
+        name: AXPSoftwareManagementCommandKeys.WorkflowActivity.CompletePhase,
+        title: `Complete ${phase}`,
+        inputs: {
+            softwareId: '{{ inputs.softwareId }}',
+            phase,
+        },
+    };
+}
+function failedToast(id, message) {
+    return {
+        id,
+        name: 'workflow-activity:show-toast',
+        title: 'Phase not ready',
+        inputs: {
+            message,
+            type: 'warning',
+        },
+    };
+}
+const softwareDefinitionWorkflowDefinition = {
+    schemaVersion: 'acorex-platform-workflow/v1',
+    name: SOFTWARE_DEFINITION_WORKFLOW_NAME,
+    title: M('Software definition', 'تعریف نرم‌افزار'),
+    description: M('Introduction → discovery → first-version scope → behavior → design → delivery planning. Each complete action is gated; AI is never required.', 'معرفی → کشف → محدوده نسخه اول → رفتار → طراحی → برنامه‌ریزی تحویل. هر تکمیل فاز شرط دارد؛ هوش مصنوعی الزامی نیست.'),
+    variables: [],
+    inputs: [
+        {
+            name: 'softwareId',
+            title: 'Software ID',
+            dataType: 'string',
+            interface: { type: 'text-editor', options: {} },
+        },
+        {
+            name: 'softwareTitle',
+            title: 'Software title',
+            dataType: 'string',
+            interface: { type: 'text-editor', options: {} },
+        },
+        {
+            name: 'ownerId',
+            title: 'Owner user ID',
+            dataType: 'string',
+            interface: { type: 'text-editor', options: {} },
+        },
+    ],
+    outputs: [],
+    extensions: {},
+    graph: {
+        startActivityId: 'introductionTask',
+        activities: [
+            {
+                id: 'introductionTask',
+                name: 'workflow-activity:human-task',
+                title: 'Introduction',
+                inputs: {
+                    title: '{{ inputs.softwareTitle }} — Introduction',
+                    description: '@software-management:workflows.definition.introduction-task.description',
+                    assignedUserIds: '{{ inputs.ownerId }}',
+                    context: {
+                        softwareId: '{{ inputs.softwareId }}',
+                        phase: 'introduction',
+                        entityType: 'SoftwareManagement.Software',
+                    },
+                    actions: {
+                        suffix: [
+                            {
+                                name: 'edit-introduction',
+                                title: '@software-management:actions.edit-introduction.title',
+                                icon: 'fa-light fa-pen',
+                                color: 'primary',
+                                command: { name: 'edit-introduction' },
+                            },
+                            {
+                                name: 'generate-kickoff',
+                                title: '@software-management:actions.generate-kickoff-sheet.title',
+                                icon: 'fa-light fa-file-lines',
+                                color: 'primary',
+                                command: { name: 'generate-kickoff' },
+                            },
+                            {
+                                name: 'submit-kickoff',
+                                title: '@software-management:actions.submit-kickoff-sheet.title',
+                                icon: 'fa-light fa-paper-plane',
+                                color: 'default',
+                                command: { name: 'submit-kickoff' },
+                            },
+                            {
+                                name: 'view-approval',
+                                title: '@software-management:actions.view-kickoff-approval.title',
+                                icon: 'fa-light fa-eye',
+                                color: 'default',
+                                command: { name: 'view-approval' },
+                            },
+                            completeAction,
+                        ],
+                    },
+                },
+            },
+            {
+                id: 'loadIntroductionForEdit',
+                name: AXPSoftwareManagementCommandKeys.WorkflowActivity.LoadIntroduction,
+                title: 'Load introduction',
+                inputs: { softwareId: '{{ inputs.softwareId }}' },
+            },
+            {
+                id: 'editIntroductionDialog',
+                name: 'workflow-activity:show-layout-popup',
+                title: 'Edit introduction',
+                inputs: {
+                    title: '@software-management:actions.edit-introduction.title',
+                    size: 'lg',
+                    context: introductionDialogContext(),
+                    layout: introductionDialogLayout(false),
+                    actions: { suffix: [dialogCancelAction, dialogSaveAction] },
+                },
+            },
+            {
+                id: 'viewIntroductionDialog',
+                name: 'workflow-activity:show-layout-popup',
+                title: 'View introduction',
+                inputs: {
+                    title: '@software-management:actions.edit-introduction.title',
+                    size: 'lg',
+                    context: introductionDialogContext(),
+                    layout: introductionDialogLayout(true),
+                    actions: { suffix: [dialogCancelAction] },
+                },
+            },
+            {
+                id: 'saveIntroductionFromTask',
+                name: AXPSoftwareManagementCommandKeys.WorkflowActivity.SaveIntroduction,
+                title: 'Save introduction',
+                inputs: {
+                    softwareId: '{{ inputs.softwareId }}',
+                    title: '{{ context.eval("outputs.last.title") }}',
+                    idea: '{{ context.eval("outputs.last.idea") }}',
+                    initialProblem: '{{ context.eval("outputs.last.initialProblem") }}',
+                    goal: '{{ context.eval("outputs.last.goal") }}',
+                    ownerId: '{{ context.eval("outputs.last.ownerId") }}',
+                    potentialUsers: '{{ context.eval("outputs.last.potentialUsers") }}',
+                    openQuestions: '{{ context.eval("outputs.last.openQuestions") }}',
+                },
+            },
+            {
+                id: 'generateKickoffFromTask',
+                name: AXPSoftwareManagementCommandKeys.Software.GenerateKickoffSheet,
+                title: 'Generate kickoff sheet',
+                inputs: { softwareId: '{{ inputs.softwareId }}' },
+            },
+            {
+                id: 'submitKickoffFromTask',
+                name: AXPSoftwareManagementCommandKeys.Software.SubmitKickoffSheet,
+                title: 'Submit kickoff sheet',
+                inputs: { softwareId: '{{ inputs.softwareId }}' },
+            },
+            {
+                id: 'loadIntroductionForStatus',
+                name: AXPSoftwareManagementCommandKeys.WorkflowActivity.LoadIntroduction,
+                title: 'Load approval status',
+                inputs: { softwareId: '{{ inputs.softwareId }}' },
+            },
+            {
+                id: 'approvalStatusDialog',
+                name: 'workflow-activity:show-layout-popup',
+                title: 'Kickoff approval status',
+                inputs: {
+                    title: '@software-management:actions.view-kickoff-approval.title',
+                    size: 'md',
+                    context: {
+                        approvalText: '{{ context.eval("outputs.last.approvalText") }}',
+                    },
+                    layout: {
+                        type: 'grid-layout',
+                        mode: 'view',
+                        options: {
+                            grid: { default: { columns: 'repeat(12, 1fr)', rows: 'repeat(1, auto)', gap: '16px' } },
+                        },
+                        children: [
+                            introductionField('@software-management:workflows.definition.approval-status.label', 'approvalText', 'large-text-editor', true),
+                        ],
+                    },
+                    actions: { suffix: [dialogCancelAction] },
+                },
+            },
+            completePhaseActivity('completeIntroduction', 'introduction'),
+            phaseTask('discoveryTask', 'discovery', 'Discovery', 'Read the approved kickoff version, collect evidence, then generate and approve a discovery report. Proceed enters scope only after that approval. Revise and stop stay in discovery.'),
+            completePhaseActivity('completeDiscovery', 'discovery'),
+            failedToast('discoveryFailedToast', 'Discovery cannot enter scope without an approved report, a recorded rationale, and validated user or problem evidence.'),
+            phaseTask('scopeTask', 'first-version-scope', 'First-version scope', 'Record essential capabilities, out-of-scope items, and success metrics.'),
+            completePhaseActivity('completeScope', 'first-version-scope'),
+            failedToast('scopeFailedToast', 'First-version scope cannot complete until discovery is approved.'),
+            phaseTask('behaviorTask', 'behavior-specification', 'Behavior specification', 'Record requirements, use cases, business rules, and acceptance criteria.'),
+            completePhaseActivity('completeBehavior', 'behavior-specification'),
+            failedToast('behaviorFailedToast', 'Behavior specification cannot complete until first-version scope is approved.'),
+            phaseTask('designTask', 'design', 'Design', 'Record data-model, UX, and technical decisions. Do not pick a stack before this phase.'),
+            completePhaseActivity('completeDesign', 'design'),
+            failedToast('designFailedToast', 'Design cannot complete until behavior specification is approved.'),
+            phaseTask('deliveryTask', 'delivery-planning', 'Delivery planning', 'Link an existing Project and tasks only after the Software definition exists. Do not clone Project or Task.'),
+            completePhaseActivity('completeDelivery', 'delivery-planning'),
+            failedToast('deliveryFailedToast', 'Delivery planning cannot complete until design is approved.'),
+            {
+                id: 'definitionFinishedToast',
+                name: 'workflow-activity:show-toast',
+                title: 'Definition complete',
+                inputs: {
+                    message: 'Software definition phases are complete. Implementation of the target product is still out of this module.',
+                    type: 'success',
+                },
+            },
+        ],
+        connections: [
+            { source: { activtyName: 'introductionTask', port: 'edit-introduction' }, target: { activtyName: 'loadIntroductionForEdit' } },
+            { source: { activtyName: 'loadIntroductionForEdit', port: 'edit' }, target: { activtyName: 'editIntroductionDialog' } },
+            { source: { activtyName: 'loadIntroductionForEdit', port: 'view' }, target: { activtyName: 'viewIntroductionDialog' } },
+            { source: { activtyName: 'loadIntroductionForEdit', port: 'Failed' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'editIntroductionDialog', port: 'submit' }, target: { activtyName: 'saveIntroductionFromTask' } },
+            { source: { activtyName: 'editIntroductionDialog', port: 'cancel' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'viewIntroductionDialog', port: 'cancel' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'saveIntroductionFromTask', port: 'Done' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'saveIntroductionFromTask', port: 'Failed' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'introductionTask', port: 'generate-kickoff' }, target: { activtyName: 'generateKickoffFromTask' } },
+            { source: { activtyName: 'generateKickoffFromTask', port: 'Done' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'generateKickoffFromTask', port: 'Failed' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'introductionTask', port: 'submit-kickoff' }, target: { activtyName: 'submitKickoffFromTask' } },
+            { source: { activtyName: 'submitKickoffFromTask', port: 'Done' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'submitKickoffFromTask', port: 'Failed' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'introductionTask', port: 'view-approval' }, target: { activtyName: 'loadIntroductionForStatus' } },
+            { source: { activtyName: 'loadIntroductionForStatus', port: 'edit' }, target: { activtyName: 'approvalStatusDialog' } },
+            { source: { activtyName: 'loadIntroductionForStatus', port: 'view' }, target: { activtyName: 'approvalStatusDialog' } },
+            { source: { activtyName: 'loadIntroductionForStatus', port: 'Failed' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'approvalStatusDialog', port: 'cancel' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'introductionTask', port: 'complete-phase' }, target: { activtyName: 'completeIntroduction' } },
+            { source: { activtyName: 'completeIntroduction', port: 'Done' }, target: { activtyName: 'discoveryTask' } },
+            { source: { activtyName: 'completeIntroduction', port: 'Failed' }, target: { activtyName: 'introductionTask' } },
+            { source: { activtyName: 'discoveryTask', port: 'complete-phase' }, target: { activtyName: 'completeDiscovery' } },
+            { source: { activtyName: 'completeDiscovery', port: 'Done' }, target: { activtyName: 'scopeTask' } },
+            { source: { activtyName: 'completeDiscovery', port: 'Failed' }, target: { activtyName: 'discoveryFailedToast' } },
+            { source: { activtyName: 'discoveryFailedToast', port: 'Done' }, target: { activtyName: 'discoveryTask' } },
+            { source: { activtyName: 'scopeTask', port: 'complete-phase' }, target: { activtyName: 'completeScope' } },
+            { source: { activtyName: 'completeScope', port: 'Done' }, target: { activtyName: 'behaviorTask' } },
+            { source: { activtyName: 'completeScope', port: 'Failed' }, target: { activtyName: 'scopeFailedToast' } },
+            { source: { activtyName: 'scopeFailedToast', port: 'Done' }, target: { activtyName: 'scopeTask' } },
+            { source: { activtyName: 'behaviorTask', port: 'complete-phase' }, target: { activtyName: 'completeBehavior' } },
+            { source: { activtyName: 'completeBehavior', port: 'Done' }, target: { activtyName: 'designTask' } },
+            { source: { activtyName: 'completeBehavior', port: 'Failed' }, target: { activtyName: 'behaviorFailedToast' } },
+            { source: { activtyName: 'behaviorFailedToast', port: 'Done' }, target: { activtyName: 'behaviorTask' } },
+            { source: { activtyName: 'designTask', port: 'complete-phase' }, target: { activtyName: 'completeDesign' } },
+            { source: { activtyName: 'completeDesign', port: 'Done' }, target: { activtyName: 'deliveryTask' } },
+            { source: { activtyName: 'completeDesign', port: 'Failed' }, target: { activtyName: 'designFailedToast' } },
+            { source: { activtyName: 'designFailedToast', port: 'Done' }, target: { activtyName: 'designTask' } },
+            { source: { activtyName: 'deliveryTask', port: 'complete-phase' }, target: { activtyName: 'completeDelivery' } },
+            { source: { activtyName: 'completeDelivery', port: 'Done' }, target: { activtyName: 'definitionFinishedToast' } },
+            { source: { activtyName: 'completeDelivery', port: 'Failed' }, target: { activtyName: 'deliveryFailedToast' } },
+            { source: { activtyName: 'deliveryFailedToast', port: 'Done' }, target: { activtyName: 'deliveryTask' } },
+        ],
+    },
+};
+
+//#region ----- Constants -----
+/** Document type name in Document Management. One kickoff sheet per Software record. */
+const DISCOVERY_KICKOFF_DOCUMENT_TYPE_NAME = 'software-discovery-kickoff';
+const DISCOVERY_KICKOFF_FILE_NAME = 'discovery-kickoff.html';
+/**
+ * Review statuses stored on DocumentManagement.Document.
+ * Same vocabulary as the EDMS document review workflow.
+ */
+const KICKOFF_REVIEW_STATUS = {
+    Draft: 'draft',
+    InReview: 'in-review',
+    Approved: 'approved',
+    Rejected: 'rejected',
+    RevisionRequested: 'revision-requested',
+};
+const KICKOFF_REVIEW_REASON_BASE_DATA = 'introduction-fields-changed';
+/** Fields whose change must not silently rewrite an approved sheet. */
+const KICKOFF_SOURCE_FIELDS = [
+    'title',
+    'idea',
+    'originalIdea',
+    'initialProblem',
+    'goal',
+    'ownerId',
+    'potentialUsers',
+    'openQuestions',
+];
+const INTRODUCTION_REQUIRED_FIELDS = ['title', 'idea', 'initialProblem', 'goal', 'ownerId'];
+const INTRODUCTION_EXIT_MESSAGE = {
+    missingFields: '@software-management:messages.introduction.missing-fields',
+    kickoffRejected: '@software-management:messages.introduction.kickoff-rejected',
+    kickoffRevision: '@software-management:messages.introduction.kickoff-revision',
+    kickoffInReview: '@software-management:messages.introduction.kickoff-in-review',
+    kickoffDraft: '@software-management:messages.introduction.kickoff-draft',
+    kickoffMissing: '@software-management:messages.introduction.kickoff-missing',
+    kickoffRequired: '@software-management:messages.introduction.kickoff-required',
+    kickoffPinMissing: '@software-management:messages.introduction.kickoff-pin-missing',
+    kickoffFingerprintMissing: '@software-management:messages.introduction.kickoff-fingerprint-missing',
+    kickoffStale: '@software-management:messages.introduction.kickoff-stale',
+    kickoffNotApproved: '@software-management:messages.introduction.kickoff-not-approved',
+    kickoffVersionMismatch: '@software-management:messages.introduction.kickoff-version-mismatch',
+    ready: '@software-management:messages.introduction.ready',
+    saved: '@software-management:messages.introduction.saved',
+};
+//#endregion
+//#region ----- Labels -----
+const CERTAINTY_LABEL = {
+    recorded: { en: 'Recorded', fa: 'ثبت‌شده' },
+    hypothesis: { en: 'Hypothesis', fa: 'فرضیه' },
+    unknown: { en: 'Unknown', fa: 'نامعلوم' },
+};
+const UNKNOWN_BODY = 'Unknown / نامعلوم';
+//#endregion
+//#region ----- Text helpers -----
+function kickoffText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+/** Review status stored as a string or as a lookup `{ id }`. */
+function kickoffStatusId(value) {
+    const direct = kickoffText(value);
+    if (direct) {
+        return direct;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return '';
+    }
+    return kickoffText(value['id']);
+}
+const LOOKUP_STUB_KEYS = new Set(['id', 'displayName', 'title', 'name', 'username', 'fullName']);
+/**
+ * Reads introduction text from a string, a locale map, or a lookup stub such as `{ id, displayName }`.
+ * A lookup stub contributes its id. Other objects contribute the first non-empty locale string.
+ */
+function introductionValueText(value) {
+    const direct = kickoffText(value);
+    if (direct) {
+        return direct;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return '';
+    }
+    const record = value;
+    const id = kickoffText(record['id']);
+    const keys = Object.keys(record);
+    if (id && keys.length > 0 && keys.every((key) => LOOKUP_STUB_KEYS.has(key))) {
+        return id;
+    }
+    const preferred = kickoffText(record['en-US']) || kickoffText(record['fa-IR']) || kickoffText(record['en-AU']);
+    if (preferred) {
+        return preferred;
+    }
+    for (const entry of Object.values(record)) {
+        const text = kickoffText(entry);
+        if (text) {
+            return text;
+        }
+    }
+    return '';
+}
+function missingIntroductionFields(software) {
+    return INTRODUCTION_REQUIRED_FIELDS.filter((field) => !introductionValueText(software[field]));
+}
+function escapeHtml$1(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function isAiDraft(source) {
+    return kickoffText(source.proposedBy) === 'ai' || kickoffText(source.origin) === 'suggestion';
+}
+function narrativeCertainty(source, body) {
+    if (!body) {
+        return 'unknown';
+    }
+    return isAiDraft(source) ? 'hypothesis' : 'recorded';
+}
+function openCertainty(body) {
+    return body ? 'hypothesis' : 'unknown';
+}
+function section(key, titleEn, titleFa, body, certainty) {
+    return {
+        key,
+        titleEn,
+        titleFa,
+        body: body || UNKNOWN_BODY,
+        certainty,
+    };
+}
+//#endregion
+//#region ----- Fingerprint -----
+function sourcePayload(source) {
+    return [
+        introductionValueText(source.title),
+        introductionValueText(source.idea),
+        introductionValueText(source.originalIdea),
+        introductionValueText(source.initialProblem),
+        introductionValueText(source.goal),
+        introductionValueText(source.ownerId),
+        introductionValueText(source.potentialUsers),
+        introductionValueText(source.openQuestions),
+        kickoffText(source.proposedBy),
+        kickoffText(source.origin),
+    ].join('\n');
+}
+/** Stable id of the introduction inputs baked into a sheet version. */
+function discoveryKickoffFingerprint(source) {
+    const payload = sourcePayload(source);
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < payload.length; index += 1) {
+        hash = Math.imul(hash ^ payload.charCodeAt(index), 0x01000193);
+    }
+    const hex = (hash >>> 0).toString(16).padStart(8, '0');
+    return `kickoff-${hex}-${payload.length}`;
+}
+//#endregion
+//#region ----- Sheet -----
+function kickoffSourceFromSoftware(software) {
+    const ownerName = kickoffText(software.ownerName) || kickoffText(software.owner?.displayName);
+    return {
+        title: software.title,
+        idea: software.idea,
+        originalIdea: software.originalIdea,
+        initialProblem: software.initialProblem,
+        goal: software.goal,
+        ownerId: software.ownerId,
+        ownerName,
+        potentialUsers: software.potentialUsers,
+        openQuestions: software.openQuestions,
+        proposedBy: software.proposedBy,
+        origin: software.origin,
+    };
+}
+/**
+ * Builds the discovery kickoff sheet from introduction fields only.
+ * Empty research items stay Unknown. Author-supplied guesses stay Hypothesis.
+ * AI text is a draft: it is never labeled as evidence or a confirmed fact.
+ */
+function buildDiscoveryKickoffSheet(source) {
+    const aiDraft = isAiDraft(source);
+    const title = introductionValueText(source.title);
+    const idea = introductionValueText(source.idea);
+    const originalIdea = introductionValueText(source.originalIdea) || idea;
+    const problem = introductionValueText(source.initialProblem);
+    const goal = introductionValueText(source.goal);
+    const owner = kickoffText(source.ownerName) || introductionValueText(source.ownerId);
+    const potentialUsers = introductionValueText(source.potentialUsers);
+    const openQuestions = introductionValueText(source.openQuestions);
+    const sections = [
+        section('title', 'Title', 'عنوان', title, narrativeCertainty(source, title)),
+        section('original-idea', 'Original Idea at Registration', 'ایدهٔ اولیه هنگام ثبت', originalIdea, narrativeCertainty(source, originalIdea)),
+        section('idea', 'Idea Description', 'شرح ایده', idea, narrativeCertainty(source, idea)),
+        section('initial-problem', 'Initial Problem', 'مسئلهٔ اولیه', problem, narrativeCertainty(source, problem)),
+        section('goal', 'Goal', 'هدف', goal, narrativeCertainty(source, goal)),
+        section('owner', 'Owner', 'مسئول', owner, owner ? 'recorded' : 'unknown'),
+        section('potential-users', 'Potential Users', 'کاربران احتمالی', potentialUsers, openCertainty(potentialUsers)),
+        section('open-questions', 'Open Research Questions', 'پرسش‌های باز تحقیق', openQuestions, openCertainty(openQuestions)),
+    ];
+    const fingerprint = discoveryKickoffFingerprint(source);
+    const plainText = renderPlainText(title, sections, aiDraft, fingerprint);
+    const html = renderHtml(title, sections, aiDraft, fingerprint);
+    return {
+        title: title || 'Discovery Kickoff Sheet',
+        fingerprint,
+        html,
+        plainText,
+        sections,
+        aiDraft,
+    };
+}
+function renderPlainText(title, sections, aiDraft, fingerprint) {
+    const lines = [
+        'Discovery Kickoff Sheet / برگهٔ آغاز کشف',
+        title ? `Title / عنوان: ${title}` : '',
+        'Unconfirmed items are marked Hypothesis or Unknown. This sheet is not evidence.',
+        'موارد تأییدنشده فرضیه یا نامعلوم‌اند. این برگه شاهد نیست.',
+    ];
+    if (aiDraft) {
+        lines.push('AI draft only. This text is not evidence and is not a confirmed fact.', 'فقط پیش‌نویس هوش مصنوعی. این متن شاهد یا واقعیت تأییدشده نیست.');
+    }
+    for (const item of sections) {
+        const label = CERTAINTY_LABEL[item.certainty];
+        lines.push('', `${item.titleEn} / ${item.titleFa} [${label.en} / ${label.fa}]`, item.body);
+    }
+    lines.push('', `Fingerprint: ${fingerprint}`);
+    return lines.filter((line) => line !== undefined).join('\n');
+}
+function renderHtml(title, sections, aiDraft, fingerprint) {
+    const blocks = sections
+        .map((item) => {
+        const label = CERTAINTY_LABEL[item.certainty];
+        return [
+            '<section>',
+            `<h2>${escapeHtml$1(item.titleEn)} / ${escapeHtml$1(item.titleFa)}</h2>`,
+            `<p class="certainty">${escapeHtml$1(label.en)} / ${escapeHtml$1(label.fa)}</p>`,
+            `<p>${escapeHtml$1(item.body).replace(/\n/g, '<br>')}</p>`,
+            '</section>',
+        ].join('');
+    })
+        .join('');
+    const aiNote = aiDraft
+        ? '<p class="banner">AI draft only. This text is not evidence and is not a confirmed fact. / فقط پیش‌نویس هوش مصنوعی. این متن شاهد یا واقعیت تأییدشده نیست.</p>'
+        : '';
+    return [
+        '<!DOCTYPE html>',
+        '<html lang="fa">',
+        '<head>',
+        '<meta charset="utf-8">',
+        `<title>${escapeHtml$1(title || 'Discovery Kickoff Sheet')}</title>`,
+        '<style>',
+        'body{font-family:Segoe UI,Tahoma,sans-serif;line-height:1.5;margin:2rem;color:#1a1a1a;}',
+        'h1{font-size:1.6rem;} h2{font-size:1.1rem;margin-bottom:0.2rem;}',
+        '.banner{background:#fff6d8;border:1px solid #e6d38a;padding:0.75rem 1rem;}',
+        '.certainty{font-size:0.85rem;color:#555;margin-top:0;}',
+        'section{margin:1.25rem 0;padding-top:0.5rem;border-top:1px solid #ddd;}',
+        '</style>',
+        '</head>',
+        '<body>',
+        '<h1>Discovery Kickoff Sheet / برگهٔ آغاز کشف</h1>',
+        '<p>Unconfirmed items are marked Hypothesis or Unknown. This sheet is not evidence. / موارد تأییدنشده فرضیه یا نامعلوم‌اند. این برگه شاهد نیست.</p>',
+        aiNote,
+        blocks,
+        `<p class="certainty">Fingerprint: ${escapeHtml$1(fingerprint)}</p>`,
+        '</body>',
+        '</html>',
+    ].join('');
+}
+function readKickoffMeta(value) {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    return value;
+}
+/** Fingerprint stored on the version, with the host document as fallback. */
+function kickoffFingerprintFromRows(version, host) {
+    return (kickoffText(readKickoffMeta(version?.metaDataForm).fingerprint) ||
+        kickoffText(readKickoffMeta(host?.metaDataForm).fingerprint));
+}
+//#endregion
+//#region ----- Review and phase gate -----
+function kickoffReviewKeepsIntroduction(statusId) {
+    return (statusId === KICKOFF_REVIEW_STATUS.Rejected ||
+        statusId === KICKOFF_REVIEW_STATUS.RevisionRequested);
+}
+/**
+ * Fills the gate check from the document when an approved host version exists
+ * but the software row has not stored that version yet.
+ * An unapproved sheet never becomes the pinned version here.
+ */
+function buildIntroductionKickoffCheck(input) {
+    if (!input) {
+        return null;
+    }
+    const statusId = kickoffStatusId(input.statusId) || kickoffStatusId(input.status);
+    const hostVersionId = kickoffText(input.hostVersionId);
+    const versionFingerprint = kickoffText(input.versionFingerprint);
+    let approvedVersionId = kickoffText(input.approvedVersionId);
+    let approvedFingerprint = kickoffText(input.approvedFingerprint);
+    if (!approvedVersionId && !approvedFingerprint && !statusId && !hostVersionId) {
+        return null;
+    }
+    if (statusId === KICKOFF_REVIEW_STATUS.Approved && hostVersionId) {
+        if (!approvedVersionId) {
+            approvedVersionId = hostVersionId;
+        }
+        if (!approvedFingerprint && versionFingerprint) {
+            approvedFingerprint = versionFingerprint;
+        }
+    }
+    return { statusId, hostVersionId, approvedVersionId, approvedFingerprint };
+}
+/**
+ * Introduction may leave only when one specific document version is approved
+ * and still matches the current introduction fields.
+ * Discovery must keep using `discoveryVersionId`, not a later draft.
+ */
+function evaluateIntroductionExit(software, kickoff) {
+    const stay = (message, discoveryVersionId = '', missingFields) => ({
+        ok: false,
+        message,
+        discoveryVersionId,
+        ...(missingFields?.length ? { missingFields } : {}),
+    });
+    const missingFields = missingIntroductionFields(software);
+    if (missingFields.length) {
+        return stay(INTRODUCTION_EXIT_MESSAGE.missingFields, '', missingFields);
+    }
+    if (!kickoff) {
+        return stay(INTRODUCTION_EXIT_MESSAGE.kickoffMissing);
+    }
+    const approvedVersionId = kickoffText(kickoff.approvedVersionId);
+    const statusId = kickoffStatusId(kickoff.statusId);
+    const hostVersionId = kickoffText(kickoff.hostVersionId);
+    const approvedFingerprint = kickoffText(kickoff.approvedFingerprint);
+    const currentFingerprint = discoveryKickoffFingerprint(software);
+    if (!approvedVersionId) {
+        if (kickoffReviewKeepsIntroduction(statusId)) {
+            return stay(statusId === KICKOFF_REVIEW_STATUS.Rejected
+                ? INTRODUCTION_EXIT_MESSAGE.kickoffRejected
+                : INTRODUCTION_EXIT_MESSAGE.kickoffRevision);
+        }
+        if (statusId === KICKOFF_REVIEW_STATUS.InReview) {
+            return stay(INTRODUCTION_EXIT_MESSAGE.kickoffInReview);
+        }
+        if (statusId === KICKOFF_REVIEW_STATUS.Draft) {
+            return stay(INTRODUCTION_EXIT_MESSAGE.kickoffDraft);
+        }
+        if (statusId === KICKOFF_REVIEW_STATUS.Approved) {
+            return stay(INTRODUCTION_EXIT_MESSAGE.kickoffPinMissing);
+        }
+        if (!statusId) {
+            return stay(INTRODUCTION_EXIT_MESSAGE.kickoffMissing);
+        }
+        return stay(INTRODUCTION_EXIT_MESSAGE.kickoffRequired);
+    }
+    if (!approvedFingerprint) {
+        return stay(INTRODUCTION_EXIT_MESSAGE.kickoffFingerprintMissing, approvedVersionId);
+    }
+    if (approvedFingerprint !== currentFingerprint) {
+        return stay(INTRODUCTION_EXIT_MESSAGE.kickoffStale, approvedVersionId);
+    }
+    if (statusId !== KICKOFF_REVIEW_STATUS.Approved) {
+        if (kickoffReviewKeepsIntroduction(statusId)) {
+            return stay(statusId === KICKOFF_REVIEW_STATUS.Rejected
+                ? INTRODUCTION_EXIT_MESSAGE.kickoffRejected
+                : INTRODUCTION_EXIT_MESSAGE.kickoffRevision, approvedVersionId);
+        }
+        return stay(INTRODUCTION_EXIT_MESSAGE.kickoffNotApproved, approvedVersionId);
+    }
+    if (!hostVersionId || hostVersionId !== approvedVersionId) {
+        return stay(INTRODUCTION_EXIT_MESSAGE.kickoffVersionMismatch, approvedVersionId);
+    }
+    return {
+        ok: true,
+        message: '',
+        discoveryVersionId: approvedVersionId,
+    };
+}
+/**
+ * PDF bytes must be rendered from the approved version's stored HTML.
+ * Rebuilding from later introduction fields is not allowed.
+ */
+function approvedKickoffPdfSource(version, approvedVersionId) {
+    const versionId = kickoffText(version?.id);
+    if (!approvedVersionId || versionId !== approvedVersionId) {
+        return {
+            ok: false,
+            html: '',
+            message: 'PDF export needs the approved kickoff sheet version.',
+        };
+    }
+    const html = kickoffText(readKickoffMeta(version?.metaDataForm).bodyHtml);
+    if (!html) {
+        return {
+            ok: false,
+            html: '',
+            message: 'The approved kickoff sheet has no readable HTML to export.',
+        };
+    }
+    return { ok: true, html, message: '' };
+}
+/**
+ * A later edit must keep the approved HTML intact and ask for a new version.
+ */
+function kickoffAfterBaseDataChange(approved, next) {
+    const nextFingerprint = discoveryKickoffFingerprint(next);
+    const changed = nextFingerprint !== approved.fingerprint;
+    return {
+        approvedHtml: approved.html,
+        needsReview: changed,
+        reviewReason: changed ? KICKOFF_REVIEW_REASON_BASE_DATA : '',
+        nextFingerprint,
+    };
+}
+//#endregion
+
+//#region ----- Constants -----
+const DISCOVERY_REPORT_DOCUMENT_TYPE_NAME = 'software-discovery-report';
+const DISCOVERY_REPORT_FILE_NAME = 'discovery-report.html';
+const DISCOVERY_DECISIONS = ['proceed', 'revise', 'stop'];
+const DISCOVERY_STANCES = ['assumption', 'validated'];
+const DISCOVERY_METHODS = [
+    'interview',
+    'observation',
+    'analytics',
+    'document',
+    'questionnaire',
+    'other',
+];
+const DISCOVERY_FINDINGS_CHANGED = 'discovery-findings-changed';
+//#endregion
+//#region ----- Findings -----
+function discoveryStance(value) {
+    return kickoffText(value) === 'validated' ? 'validated' : 'assumption';
+}
+function parseSourceRefs(value) {
+    return kickoffText(value)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function findingSupportsProceed(finding) {
+    const kind = kickoffText(finding.kind);
+    const userOrProblem = kind === 'audience' || kind === 'problem' || kind === 'pain';
+    const hasEvidence = Boolean(kickoffText(finding.method) || parseSourceRefs(finding.sourceRefs).length);
+    return discoveryStance(finding.stance) === 'validated' && userOrProblem && hasEvidence && Boolean(kickoffText(finding.claim) || kickoffText(finding.title));
+}
+function discoveryReportFingerprint(source) {
+    const findings = [...source.findings]
+        .map((finding) => [
+        kickoffText(finding.id),
+        kickoffText(finding.kind),
+        kickoffText(finding.title),
+        kickoffText(finding.body),
+        discoveryStance(finding.stance),
+        kickoffText(finding.method),
+        kickoffText(finding.researchDate),
+        kickoffText(finding.userGroup),
+        kickoffText(finding.claim),
+        parseSourceRefs(finding.sourceRefs).join('|'),
+        kickoffText(finding.kickoffVersionId),
+    ].join('\u001f'))
+        .sort();
+    const payload = [source.kickoffVersionId, source.decision, source.rationale, ...findings].join('\u001e');
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < payload.length; index += 1) {
+        hash ^= payload.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `discovery-${(hash >>> 0).toString(16).padStart(8, '0')}-${payload.length}`;
+}
+//#endregion
+//#region ----- Report -----
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function kickoffPlainTextFromVersion(version) {
+    const meta = readKickoffMeta(version?.metaDataForm);
+    return kickoffText(meta.plainText) || kickoffText(meta.bodyHtml);
+}
+function buildDiscoveryReport(source) {
+    const fingerprint = discoveryReportFingerprint(source);
+    const lines = [
+        'Discovery Report / گزارش کشف',
+        `Kickoff version / نسخهٔ آغاز: ${source.kickoffVersionId}`,
+        'Assumptions stay labeled as assumptions. Validated findings cite a method or source.',
+        'فرضیه‌ها فرضیه می‌مانند. یافتهٔ اعتبارسنجی‌شده روش یا منبع دارد.',
+        '',
+        'Pinned introduction / معرفی تأییدشده',
+        source.kickoffPlainText || 'Unknown / نامعلوم',
+        '',
+        `Decision / تصمیم: ${source.decision || 'Unknown / نامعلوم'}`,
+        `Rationale / دلیل: ${source.rationale || 'Unknown / نامعلوم'}`,
+    ];
+    for (const finding of source.findings) {
+        const sources = parseSourceRefs(finding.sourceRefs);
+        lines.push('', `${kickoffText(finding.kind) || 'item'} / ${discoveryStance(finding.stance)}`, kickoffText(finding.title) || 'Unknown / نامعلوم', kickoffText(finding.claim) || kickoffText(finding.body) || 'Unknown / نامعلوم', `Method / روش: ${kickoffText(finding.method) || 'Unknown / نامعلوم'}`, `User group / گروه کاربر: ${kickoffText(finding.userGroup) || 'Unknown / نامعلوم'}`, `Date / تاریخ: ${kickoffText(finding.researchDate) || 'Unknown / نامعلوم'}`, `Sources / منابع: ${sources.length ? sources.join('; ') : 'Unknown / نامعلوم'}`, `Kickoff version / نسخه: ${kickoffText(finding.kickoffVersionId) || source.kickoffVersionId}`);
+    }
+    lines.push('', `Fingerprint: ${fingerprint}`);
+    const plainText = lines.join('\n');
+    const html = [
+        '<!DOCTYPE html>',
+        '<html>',
+        '<head><meta charset="utf-8"><title>Discovery Report</title></head>',
+        '<body>',
+        `<pre>${escapeHtml(plainText)}</pre>`,
+        '</body>',
+        '</html>',
+    ].join('');
+    return { fingerprint, html, plainText };
+}
+//#endregion
+//#region ----- Exit gate -----
+function evaluateDiscoveryExit(input) {
+    const stay = (message, discoveryVersionId = '') => ({
+        ok: false,
+        advance: false,
+        message,
+        discoveryVersionId,
+    });
+    const phase = kickoffText(input.currentPhase);
+    const decision = kickoffText(input.decision);
+    const approvedVersionId = kickoffText(input.approvedVersionId);
+    const fingerprint = kickoffText(input.reportFingerprint);
+    const approvedFingerprint = kickoffText(input.approvedFingerprint);
+    const hostVersionId = kickoffText(input.hostVersionId);
+    const statusId = kickoffText(input.statusId);
+    if (phase && phase !== 'discovery' && phase !== 'introduction') {
+        return { ok: true, advance: false, message: '', discoveryVersionId: approvedVersionId };
+    }
+    if (!kickoffText(input.kickoffApprovedVersionId)) {
+        return stay('Discovery needs the approved introduction kickoff version.');
+    }
+    if (decision !== 'proceed' && decision !== 'revise' && decision !== 'stop') {
+        return stay('Discovery needs a decision: proceed, revise, or stop.');
+    }
+    if (!kickoffText(input.rationale)) {
+        return stay('Discovery needs a recorded rationale for the decision.');
+    }
+    if (!approvedVersionId || statusId !== 'approved' || hostVersionId !== approvedVersionId) {
+        return stay('Discovery needs an approved discovery report before the phase can change.');
+    }
+    if (!fingerprint || approvedFingerprint !== fingerprint) {
+        return stay('Discovery findings changed after approval. The approved report was not changed. Generate and approve a new report.', approvedVersionId);
+    }
+    if (decision === 'revise' || decision === 'stop') {
+        return {
+            ok: true,
+            advance: false,
+            message: decision === 'stop'
+                ? 'Discovery stops here. The approved report is kept and Scope does not start.'
+                : 'Discovery stays open for revision. The approved report is kept and Scope does not start.',
+            discoveryVersionId: approvedVersionId,
+        };
+    }
+    const findings = input.findings ?? [];
+    if (!findings.some(findingSupportsProceed)) {
+        return stay('Proceed needs at least one validated user or problem finding with a method or source. A questionnaire alone is not a conclusion.', approvedVersionId);
+    }
+    return {
+        ok: true,
+        advance: true,
+        message: '',
+        discoveryVersionId: approvedVersionId,
+    };
+}
+//#endregion
+
+function textPresent(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function canCompleteIntroduction(software) {
+    return missingIntroductionFields(software).length === 0;
+}
+function isIntroductionComplete(software) {
+    if (software.introductionCompletedAt) {
+        return true;
+    }
+    return isSoftwarePhaseAtLeast(String(software.currentPhase ?? ''), 'discovery');
+}
+function canLinkProject(software) {
+    return isIntroductionComplete(software);
+}
+function canWriteDesignKind(software, kind) {
+    if (kind === 'technical') {
+        return isSoftwarePhaseAtLeast(String(software.currentPhase ?? ''), 'design');
+    }
+    return isSoftwarePhaseAtLeast(String(software.currentPhase ?? ''), 'behavior-specification');
+}
+const INTRODUCTION_UPSTREAM_FIELDS = [
+    'title',
+    'idea',
+    'initialProblem',
+    'goal',
+    'ownerId',
+    'potentialUsers',
+    'openQuestions',
+];
+function canCompletePhase(phase, software, kickoff, discovery) {
+    if (phase === 'discovery') {
+        const decision = evaluateDiscoveryExit({
+            currentPhase: software.currentPhase,
+            ...discovery,
+        });
+        return { ok: decision.ok, message: decision.message, advance: decision.advance };
+    }
+    if (phase === 'introduction') {
+        const alreadyLeftIntroduction = isIntroductionComplete(software) && kickoffText(software.currentPhase) !== 'introduction';
+        if (alreadyLeftIntroduction) {
+            return { ok: true, message: '' };
+        }
+        const decision = evaluateIntroductionExit(software, kickoff);
+        return { ok: decision.ok, message: decision.message, missingFields: decision.missingFields };
+    }
+    if (software.currentPhase !== phase) {
+        const next = nextSoftwarePhase(phase);
+        if (next && isSoftwarePhaseAtLeast(String(software.currentPhase ?? ''), next)) {
+            return { ok: true, message: '' };
+        }
+        return {
+            ok: false,
+            message: `Software must be in ${phase} before this phase can complete.`,
+        };
+    }
+    return { ok: true, message: '' };
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXPSoftwareManagementCommandKeys, AXPSoftwareManagementMenuKeys, AXPSoftwareManagementPermissionKeys, DISCOVERY_DECISIONS, DISCOVERY_FINDINGS_CHANGED, DISCOVERY_KICKOFF_DOCUMENT_TYPE_NAME, DISCOVERY_KICKOFF_FILE_NAME, DISCOVERY_METHODS, DISCOVERY_REPORT_DOCUMENT_TYPE_NAME, DISCOVERY_REPORT_FILE_NAME, DISCOVERY_STANCES, INTRODUCTION_EXIT_MESSAGE, INTRODUCTION_REQUIRED_FIELDS, INTRODUCTION_UPSTREAM_FIELDS, KICKOFF_REVIEW_REASON_BASE_DATA, KICKOFF_REVIEW_STATUS, KICKOFF_SOURCE_FIELDS, RootConfig, SOFTWARE_DEFINITION_WORKFLOW_NAME, SOFTWARE_DESIGN_KINDS, SOFTWARE_DISCOVERY_KINDS, SOFTWARE_ORIGINS, SOFTWARE_PHASES, SOFTWARE_PROPOSED_BY, SOFTWARE_SCOPE_KINDS, SoftwareManagementManifest, approvedKickoffPdfSource, buildDiscoveryKickoffSheet, buildDiscoveryReport, buildIntroductionKickoffCheck, canCompleteIntroduction, canCompletePhase, canLinkProject, canWriteDesignKind, discoveryKickoffFingerprint, discoveryReportFingerprint, discoveryStance, evaluateDiscoveryExit, evaluateIntroductionExit, findingSupportsProceed, introductionValueText, isIntroductionComplete, isSoftwarePhaseAtLeast, kickoffAfterBaseDataChange, kickoffFingerprintFromRows, kickoffPlainTextFromVersion, kickoffReviewKeepsIntroduction, kickoffSourceFromSoftware, kickoffStatusId, kickoffText, missingIntroductionFields, nextSoftwarePhase, parseSourceRefs, readKickoffMeta, softwareDefinitionWorkflowDefinition, softwarePhaseIndex, textPresent };
+//# sourceMappingURL=acorex-platform-module-software-management-client-contracts.mjs.map