# Phase 1: Stabilize & Launch Core Team Platform (businessite_core)

## Status (28 July 2026): **Shipped (core) + PM join**
Live on local + online cloud-dev/qa/prod (module ≥19.0.1.3.7):
- 20 open public posts (5 solution layers × 4 roles) on `/businessite/core/recruit`
- Chrome-hidden public recruit/apply/setup pages
- Appointment → SLUG + SA junior/intern contract + assign layer/role Odoo tasks
- 5 Odoo team projects (Data/System/Security/User/App) with phase×role backlog from roadmap
- **BusinesSite PM hub** `BS-CORE` + **layer subprojects** `BS-DATA` … `BS-APP` (members, teams, roles, budget, phases, timesheets, events)
- **On Appoint / onboard:** member auto-joins their **layer subproject** + team (architect→manager, analyst→lead, admin/developer→member); architects/analysts also viewer on hub
- Chat: `project help` · `my projects` · `show project BusinesSite Layer — Data`
- Backend: **BusinesSite → Projects → My / business projects**
- SA pay grades: Intern R6 500 · Junior R15 000 · Junior Architect R18 000 (ZAR)

## Objectives
- Implement the `businessite_core` Odoo module for managing internal core users.
- Define and enforce 4 roles: Architect, Analyst, Admin, Developer.
- Define 5 solution teams: Data, System, Security, User, App.
- Enable public recruitment, applications, and automated appointment with unique **DEV_SLUG** generation.
- Automatically provision personal **cloud mirrors** (copies of main cloud-dev) and provide **one-click localhost bootstrap** scripts for new team members (personal dev/qa/prod as full copies of their cloud mirror).
- Support the full promotion pipeline: local dev → local qa (UAT) → local prod → personal cloud mirror → senior review → master cloud-dev.
- Provide personalized setup guides and admin training for scalable onboarding.

## Key Technical Deliverables
- `businessite_core` module with:
  - `businessite.core.position` (by layer + role, open/closed status).
  - `businessite.core.application` (public apply flow).
  - `businessite.core.team_member` (auto-generated unique SLUG on appointment, linked to client profile).
  - Computed fields: `slug`, `cloud_mirror` (e.g. `cloud-dev-da01`), `db_name_dev`, `docker_name`, `setup_guide`.
- Public recruitment: `/businessite/core/recruit` + role-specific apply forms.
- Automated onboarding:
  - On appointment: auto SLUG + task creation for "Provision personal cloud mirror".
  - Cloud admin script: `create_personal_cloud_mirror.sh ` (git worktree + DB/filestore copy from main + docker skeleton).
  - Member bootstrap: `bootstrap_personal_localhost_from_cloud_mirror.sh ` (creates local docker dev/qa/prod + full initial sync from personal cloud mirror).
- Downloadable personalized bootstrap script from the member's guide page (`/businessite/core/setup`).
- Admin UI: "Provision Cloud Mirror (Admin)" button + full guide.
- Integration with UAT system and code promotion scripts (all SLUG-aware).
- Training guide: `CORE_TEAM_ONBOARDING_TRAINING_GUIDE.md` for admins and new members.

## Homepage / Roadmap UX Impact
- "For the Core Team" section with "Join the Core Team" CTA linking to recruitment.
- Roadmap Phase 1 now highlights **automated SLUG-based environments** and **cloud-to-localhost bootstrap** (no manual setup required).
- New members experience the full journey end-to-end via the module.

## Environment & Promotion Model
- Each member gets:
  - Unique SLUG (e.g. `da01`, `sa02`).
  - Personal cloud mirror: `cloud-dev-${SLUG}`.
  - Localhost: dev (`${SLUG}-dev`), qa, prod — all starting as copies of their cloud mirror.
- Workflow: develop + auto-test locally → promote changes via qa/prod → push to personal cloud mirror → review → integrate to master cloud-dev.

## Recruitment & Adoption Value
- Public apply → review → appoint flow with zero manual environment setup.
- Demonstrates professional, scalable team tooling and automated developer experience.
- Powerful for attracting core team members across layers/roles.
- Full audit trail via tasks, applications, and UAT results.

## Dependencies
- Existing businessite models (client, UAT, etc.).
- Docker + git worktree infrastructure on cloud and localhost.
- SLUG-aware scripts in `~/docker/scripts/`.

## Success Criteria
- New core member can apply publicly, get appointed, have cloud mirror provisioned, and bootstrap complete localhost instances with a single script.
- Appointed member appears on the correct **layer PM subproject** (members + team) and can see assigned roadmap tasks; can log time / report status via chat.

## Core team → PM mapping

| Core layer | PM subproject code | Default team |
|------------|--------------------|--------------|
| data | BS-DATA | Data Team |
| system | BS-SYSTEM | System Team |
| user | BS-USER | User Team |
| security | BS-SECURITY | Security Team |
| app | BS-APP | App Team |

| Core role | PM role |
|-----------|---------|
| architect | manager |
| analyst | lead |
| admin | member |
| developer | member |

Hub code: **BS-CORE** (parent of the five layer subprojects).
- Full promotion pipeline works end-to-end with personal mirrors.
- Admins have clear provisioning commands and training guide.
- Demo of recruitment + onboarding visible on homepage/roadmap.

## Further Reading
- [businessite_core Module Design](businessite_core_design.md)
- [Core Roles & Permissions Matrix](core_roles_matrix.md)
- [Core Team Onboarding Training Guide](../CORE_TEAM_ONBOARDING_TRAINING_GUIDE.md) (in businessite_core/docs)
- Main scripts: `create_personal_cloud_mirror.sh`, `bootstrap_personal_localhost_from_cloud_mirror.sh`
- UAT integration in businessite module

## Detailed Tasks by Layer and Role (for full implementation)

### Data Layer
- **Architect**: Define data models and relations for this phase (e.g. new tables for phase-specific entities).
- **Analyst**: Specify data validation rules, reports, and analytics for the phase.
- **Admin**: Seed initial data, configure access rights, and set up data migration scripts.
- **Developer**: Implement CRUD operations, constraints, and data sync logic.

### System Layer
- **Architect**: Design system architecture, services, and integration points for the phase.
- **Analyst**: Map system workflows, error handling, and performance requirements.
- **Admin**: Configure system parameters, cron jobs, and environment setups.
- **Developer**: Code the backend services, APIs, and background jobs for the phase.

### User Layer
- **Architect**: Design user interfaces and UX flows for the phase (web and mobile).
- **Analyst**: Define user stories, permissions, and role-based access for the phase.
- **Admin**: Set up user training, roles matrix, and onboarding for the phase.
- **Developer**: Build the UI components, controllers, and client-side logic for user interactions.

### Security Layer
- **Architect**: Design security model, authentication, and audit for phase features.
- **Analyst**: Identify security risks and compliance requirements for the phase.
- **Admin**: Configure groups, rules, and access controls; review logs.
- **Developer**: Implement security checks, encryption, and access decorators in code.

### App Layer
- **Architect**: Define app-specific features, integrations with mobile and external apps.
- **Analyst**: Specify app data models and sync requirements.
- **Admin**: Manage app configurations, publish settings, and user grants.
- **Developer**: Code the app-specific models, views, and integration points (e.g. chat commands, mobile features).